MCP Servers

Discover Awesome MCP Servers

Extend your agent with 73,548 capabilities via MCP servers.

All73,548

Image Generation MCP Server

Gương của

Claude-LMStudio Bridge

Một máy chủ MCP cho phép Claude tương tác với các LLM cục bộ đang chạy trong LM Studio, cung cấp quyền truy cập để liệt kê các mô hình, tạo văn bản và sử dụng các hoàn thành trò chuyện thông qua các mô hình cục bộ.

Example MCP Server + Client Implementation

A demo implementation of a MCP server (consuming a dummy API) and basic client.

Meilisearch MCP Server (Go)

Go-based MCP server wrapper for Meilisearch, enabling LLMs like Claude to access powerful search capabilities via Model Context Protocol

mcp

A collection of MCP servers for various tasks

🚀 Model Context Protocol (MCP) Server Python Template 🐍

Một nền tảng tinh gọn để xây dựng các máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) trong Python, được thiết kế để giúp việc phát triển các công cụ MCP được hỗ trợ bởi AI trở nên dễ dàng và hiệu quả hơn.

OpenDota MCP Server

Gương của

Unsplash MCP Server

Một máy chủ nhẹ cho phép tích hợp liền mạch với thư viện ảnh của Unsplash, cho phép các nhà phát triển tìm kiếm ảnh chất lượng cao với nhiều bộ lọc khác nhau trực tiếp từ trình soạn thảo Cursor.

Crypto Indicators MCP Server

Một máy chủ MCP cung cấp một loạt các chỉ báo và chiến lược phân tích kỹ thuật tiền điện tử.

Swytchcode MCP server

Swytchcode accelerates API integrations, allowing developers to seamlessly integrate any API using Postman collections or OpenAPI specifications. With Swytchcode, developers can obtain production-ready code in their preferred programming language, reducing integration time by up to 90%. The Swytchcode platform supports code generation for over 80 APIs, with the capability to add more APIs on demand. This streamlined approach empowers developers to focus on innovation rather than tedious integration tasks. Key Features: API Support: Integrates with 80+ APIs, including popular fintech services like Stripe, PayPal, and Shopify. Code Generation: Produces code in multiple programming languages, ensuring compatibility with various development environments. On-Demand API Addition: Allows developers to request support for additional APIs as needed.

dicom-mcp: A DICOM Model Context Protocol Server

Cho phép các trợ lý AI truy vấn và phân tích siêu dữ liệu hình ảnh y tế từ các máy chủ DICOM, bao gồm thông tin bệnh nhân, nghiên cứu, chuỗi và phiên bản, cũng như trích xuất văn bản từ các tài liệu PDF được đóng gói.

Model Context Protocol and Fireproof Demo: JSON Document Server

Mirror of

Freqtrade-MCP

Một máy chủ MCP tích hợp với bot giao dịch tiền điện tử Freqtrade.

mcp-simple-server-cursor

MCP Server: VS Code Extensions Installer

MCP tool for automatically installing VS Code extensions in Cursor

MCP-Agg: Multi-Channel Platform Aggregator

Máy chủ MCP tổng hợp

Database MCP Server

Một máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) cung cấp các công cụ để kết nối và tương tác với nhiều hệ thống cơ sở dữ liệu khác nhau (SQLite, PostgreSQL, MySQL/MariaDB, SQL Server) thông qua một giao diện thống nhất.

MCP Tools

Mirror of

Mcp Api

mcp client and server

Script Tool

Máy chủ MCP để chạy tập lệnh

MCP Harbor

Một ứng dụng Node.js cung cấp một máy chủ Model Context Protocol để tương tác với Harbor container registry, hỗ trợ các thao tác cho các dự án, kho lưu trữ (repositories), thẻ (tags) và biểu đồ Helm.

CF-MCP-Server

MCP (Model Context Protocol) Research

Okay, here's a translation of your request and some information about Model Context Protocol (MCP) servers and implementations, focusing on what's likely relevant given the context of the request: **Translation of Request:** **Tiếng Việt:** Nghiên cứu và tài liệu về máy chủ và triển khai Giao thức Ngữ cảnh Mô hình (Model Context Protocol - MCP). **Explanation and Information about Model Context Protocol (MCP) Servers and Implementations:** The term "Model Context Protocol" (MCP) isn't a widely recognized or standardized protocol in the same way as, say, HTTP or TCP/IP. It's likely a term used within a specific project, company, or research domain. Therefore, finding general documentation is difficult. To understand it, we need to consider what it *might* be referring to. Here are a few possibilities and how to approach researching them: **Possible Interpretations and Research Strategies:** 1. **Proprietary Protocol:** The most likely scenario is that MCP is a custom protocol developed internally by a company or research group. In this case, the *only* documentation will be internal to that organization. You'll need to: * **Identify the Origin:** Figure out where the term "Model Context Protocol" is used. Who coined the term? In what project or system is it used? * **Access Internal Documentation:** Once you know the origin, you'll need to access the internal documentation, specifications, and code related to that project. This might involve contacting the developers or project managers. * **Reverse Engineering (If Necessary):** If documentation is scarce, you might need to reverse engineer the protocol by analyzing network traffic, examining the server and client code, and observing the system's behavior. This is a difficult and time-consuming process. 2. **Domain-Specific Protocol (e.g., Simulation, Modeling, AI):** It's possible that MCP is a protocol used within a specific domain, such as: * **Simulation and Modeling:** Perhaps it's used to exchange context information between different simulation components or models. Look for protocols used in distributed simulation, co-simulation, or model integration. Keywords to search for include "High Level Architecture (HLA)," "Distributed Interactive Simulation (DIS)," "Functional Mock-up Interface (FMI)," and "co-simulation protocols." * **AI and Machine Learning:** It could be related to sharing model metadata, training data context, or model deployment information. Look for protocols or standards related to model serving, model governance, or federated learning. Keywords to search for include "MLflow," "Kubeflow," "Seldon Core," "ONNX Runtime," and "model serving protocols." * **Game Development:** Less likely, but it could be a custom protocol for sharing game state or context between game clients and servers. **Research Strategy:** * **Identify the Domain:** Determine the specific domain where you encountered the term "Model Context Protocol." * **Search for Domain-Specific Protocols:** Search for protocols and standards used in that domain that relate to context sharing, model management, or data exchange. * **Look for Open-Source Implementations:** If you find a relevant protocol, look for open-source implementations of servers and clients. 3. **Misspelling or Abbreviation:** It's also possible that "MCP" is a misspelling or abbreviation of a more common protocol or technology. Consider alternative spellings or similar-sounding acronyms. **General Considerations for MCP Servers and Implementations (Assuming it's a custom protocol):** If you're dealing with a custom protocol, here are some general considerations for designing and implementing MCP servers: * **Protocol Definition:** * **Data Format:** What data format is used (e.g., JSON, XML, Protocol Buffers, custom binary format)? Choose a format that is efficient, easy to parse, and well-supported by your programming languages. * **Message Structure:** Define the structure of the messages exchanged between the client and server. What fields are included? What data types are used? * **Communication Pattern:** Is it a request-response protocol, a publish-subscribe protocol, or something else? * **Server Architecture:** * **Programming Language:** Choose a programming language that is well-suited for network programming and that you are familiar with (e.g., Python, Java, Go, C++). * **Networking Library:** Use a robust networking library to handle the low-level details of network communication (e.g., `socket` library in Python, `java.net` in Java, `net` package in Go). * **Concurrency Model:** Decide how the server will handle multiple concurrent client connections (e.g., multi-threading, asynchronous I/O). * **Security:** * **Authentication:** How will clients authenticate themselves to the server? * **Authorization:** What permissions will different clients have? * **Encryption:** Will the communication be encrypted (e.g., using TLS/SSL)? * **Error Handling:** * **Error Codes:** Define a set of error codes to indicate different types of errors. * **Logging:** Implement robust logging to track server activity and diagnose problems. * **Scalability:** * **Load Balancing:** If the server needs to handle a large number of clients, consider using load balancing to distribute the load across multiple servers. * **Caching:** Use caching to improve performance by storing frequently accessed data in memory. * **Monitoring:** * **Metrics:** Collect metrics about server performance (e.g., CPU usage, memory usage, network traffic). * **Alerting:** Set up alerts to notify you of potential problems. **Example (Illustrative - Assuming a Simple Request-Response Protocol with JSON):** Let's imagine MCP is a simple protocol where clients request information about a model, and the server responds with the model's context (e.g., metadata, parameters). * **Request (JSON):** ```json { "request_type": "get_model_context", "model_id": "model_123" } ``` * **Response (JSON):** ```json { "status": "success", "model_context": { "name": "My Model", "version": "1.0", "description": "A simple model", "parameters": { "learning_rate": 0.01, "batch_size": 32 } } } ``` **Implementation (Conceptual Python Example):** ```python import socket import json def handle_client(conn, addr): print(f"Connected by {addr}") data = conn.recv(1024) # Receive up to 1024 bytes if not data: return try: request = json.loads(data.decode('utf-8')) if request['request_type'] == 'get_model_context': model_id = request['model_id'] # Simulate fetching model context from a database or file model_context = { "name": f"Model {model_id}", "version": "1.0", "description": "A sample model context", "parameters": {"param1": 1.0, "param2": 2.0} } response = { "status": "success", "model_context": model_context } conn.sendall(json.dumps(response).encode('utf-8')) else: response = {"status": "error", "message": "Invalid request type"} conn.sendall(json.dumps(response).encode('utf-8')) except json.JSONDecodeError: response = {"status": "error", "message": "Invalid JSON"} conn.sendall(json.dumps(response).encode('utf-8')) except Exception as e: response = {"status": "error", "message": str(e)} conn.sendall(json.dumps(response).encode('utf-8')) finally: conn.close() def main(): HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) if __name__ == "__main__": main() ``` **Important Considerations:** * **This is a very basic example.** A real-world MCP server would need to handle authentication, authorization, error handling, and other complexities. * **Replace the simulated model context retrieval with actual logic.** The example just returns a hardcoded context. * **Choose the right data format and communication pattern for your needs.** JSON and request-response are just one possibility. **In summary, to effectively research and document MCP servers and implementations, you need to first determine the context in which the term is used. Once you know the origin and purpose of MCP, you can then search for relevant documentation, specifications, and code examples.** Good luck!