Discover Awesome MCP Servers

github-readme-mcp

An MCP server that reviews README files using transparent, deterministic rules, scoring them and suggesting improvements.

AutoCAD MCP Server

Enables users to control AutoCAD, GstarCAD, or ZWCAD through natural language via Claude Desktop. It provides tools for drawing geometric shapes, adding text and dimensions, and managing CAD files using the Windows COM interface.

Tavily Search

Una implementación de servidor MCP que integra la API de Búsqueda de Tavily, proporcionando capacidades de búsqueda optimizadas para LLMs.

MCP 만들면서 원리 파헤쳐보기

Okay, here's a breakdown of the server and client implementation for a system conceptually similar to the MCP (Master Control Program) from the movie TRON, along with considerations for a modern, practical application. Keep in mind that a real-world MCP would be far more complex, but this provides a foundational structure. **Translation:** Implementación del servidor y del cliente para MCP (Programa de Control Maestro) --- **Conceptual Overview** The MCP, in essence, is a central authority that manages resources, enforces rules, and potentially monitors activity within a system. In a modern context, this could translate to: * **Resource Management:** Allocating CPU time, memory, network bandwidth, or access to specific services. * **Security and Access Control:** Authenticating users/programs and granting permissions. * **Monitoring and Logging:** Tracking system activity for performance analysis, security audits, or debugging. * **Orchestration:** Coordinating the execution of tasks across multiple systems. **Simplified Architecture** We'll use a client-server architecture. * **Server (MCP):** The central authority. It listens for requests from clients, processes them, and sends back responses. * **Client (Programs/Users):** Entities that interact with the MCP to request resources, execute tasks, or access services. **Implementation Considerations (General)** * **Language:** Choose a language suitable for both server and client development. Python, Java, Go, or C++ are common choices. Python is often favored for rapid prototyping and ease of use. * **Communication Protocol:** Select a protocol for communication between the client and server. Options include: * **TCP Sockets:** Reliable, connection-oriented communication. Good for persistent connections and guaranteed delivery. * **HTTP/REST:** Stateless, request-response model. Suitable for simpler interactions and integration with web-based systems. * **gRPC:** A modern, high-performance RPC framework. Uses Protocol Buffers for efficient serialization. * **Message Queues (e.g., RabbitMQ, Kafka):** Asynchronous communication. Useful for decoupling components and handling high volumes of requests. * **Security:** Implement robust authentication and authorization mechanisms. Use TLS/SSL for secure communication. Consider role-based access control (RBAC). * **Data Serialization:** Choose a format for encoding data exchanged between the client and server. Options include JSON, XML, Protocol Buffers, or MessagePack. * **Error Handling:** Implement proper error handling on both the client and server sides. Provide informative error messages to the client. * **Scalability:** Design the server to handle a large number of concurrent clients. Consider using techniques like multithreading, asynchronous I/O, or load balancing. **Example Implementation (Python with TCP Sockets)** This is a simplified example to illustrate the basic concepts. It lacks many features of a production-ready system. **Server (mcp_server.py):** ```python import socket import threading HOST = '127.0.0.1' # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) def handle_client(conn, addr): print(f"Connected by {addr}") while True: data = conn.recv(1024) if not data: break message = data.decode('utf-8') print(f"Received from {addr}: {message}") # **MCP Logic (Example: Resource Allocation)** if message.startswith("REQUEST_RESOURCE"): resource_type, amount = message.split(":")[1], message.split(":")[2] print(f"Allocating {amount} of {resource_type} to {addr}") response = f"RESOURCE_ALLOCATED:{resource_type}:{amount}" #Simulated allocation elif message.startswith("EXECUTE_TASK"): task_name = message.split(":")[1] print(f"Executing task {task_name} for {addr}") response = f"TASK_EXECUTED:{task_name}" #Simulated execution else: response = "UNKNOWN_COMMAND" conn.sendall(response.encode('utf-8')) conn.close() print(f"Connection closed with {addr}") 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() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() ``` **Client (mcp_client.py):** ```python import socket HOST = '127.0.0.1' # The server's hostname or IP address PORT = 65432 # The port used by the server with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) # Example 1: Request a resource message1 = "REQUEST_RESOURCE:CPU:10" s.sendall(message1.encode('utf-8')) data1 = s.recv(1024) print(f"Received: {data1.decode('utf-8')}") # Example 2: Execute a task message2 = "EXECUTE_TASK:CalculatePi" s.sendall(message2.encode('utf-8')) data2 = s.recv(1024) print(f"Received: {data2.decode('utf-8')}") print("Client finished.") ``` **Explanation:** * **Server:** * Creates a TCP socket and listens for incoming connections. * When a client connects, it spawns a new thread to handle the client's requests concurrently. * Receives data from the client, decodes it, and processes it based on the command. * Sends a response back to the client. * Closes the connection when the client disconnects. * **Client:** * Creates a TCP socket and connects to the server. * Sends a message to the server. * Receives the response from the server. * Prints the response. * Closes the connection. **How to Run:** 1. Save the server code as `mcp_server.py` and the client code as `mcp_client.py`. 2. Open two terminal windows. 3. In the first terminal, run the server: `python mcp_server.py` 4. In the second terminal, run the client: `python mcp_client.py` **Important Considerations and Enhancements:** * **Authentication:** Implement a proper authentication mechanism (e.g., username/password, API keys, certificates) to verify the identity of clients. * **Authorization:** Use role-based access control (RBAC) to define what actions each client is allowed to perform. * **Resource Management:** Implement a more sophisticated resource allocation algorithm. Consider using quotas, priorities, and scheduling. * **Task Management:** Implement a task queue to manage the execution of tasks. Use a message queue (e.g., RabbitMQ, Kafka) for asynchronous task processing. * **Error Handling:** Implement more robust error handling on both the client and server sides. Provide informative error messages to the client. * **Logging:** Log all important events (e.g., client connections, resource allocations, task executions, errors) for auditing and debugging. * **Scalability:** Design the server to handle a large number of concurrent clients. Consider using techniques like multithreading, asynchronous I/O, or load balancing. * **Security:** Use TLS/SSL for secure communication. Protect against common security vulnerabilities (e.g., injection attacks, cross-site scripting). * **Configuration:** Use a configuration file to store settings like the server's hostname, port number, and resource limits. * **Monitoring:** Implement monitoring to track the server's performance and resource usage. Use tools like Prometheus and Grafana. * **Persistence:** Store the state of the system (e.g., resource allocations, task queues) in a database. **Example with HTTP/REST (Conceptual)** * **Server (using Flask or FastAPI in Python):** * Defines REST endpoints for resource allocation, task execution, etc. * Handles HTTP requests from clients. * Returns JSON responses. * **Client:** * Sends HTTP requests to the server's REST endpoints. * Parses the JSON responses. **Example REST Endpoint (Resource Allocation):** * **Endpoint:** `/resources` (POST) * **Request Body (JSON):** ```json { "resource_type": "CPU", "amount": 10, "client_id": "user123" } ``` * **Response Body (JSON):** ```json { "status": "success", "message": "Resource allocated", "resource_id": "cpu-12345" } ``` **Choosing the Right Approach** * **TCP Sockets:** Good for persistent connections, real-time communication, and custom protocols. More complex to implement than HTTP/REST. * **HTTP/REST:** Good for simpler interactions, integration with web-based systems, and stateless communication. Easier to implement than TCP sockets. * **gRPC:** Good for high-performance communication, efficient serialization, and code generation. Requires more setup than HTTP/REST. * **Message Queues:** Good for asynchronous communication, decoupling components, and handling high volumes of requests. Adds complexity to the architecture. This detailed explanation and example should give you a solid foundation for building your own MCP-like system. Remember to prioritize security, scalability, and maintainability in your design. Good luck!

garmin-mcp-bridge

Brings Garmin training data into Claude via Intervals.icu, enabling querying of activities, wellness, and planned workouts, as well as creating structured workouts that sync back to the Garmin watch.

ascript-mcp

Enables AI programming tools to query AScript API documentation and control real Android/iOS devices for automation scripting, including device interaction, development deployment, and file management.

video-transcriber-mcp

Enables high-performance, offline transcription of videos from 1000+ platforms and local files using whisper.cpp, with support for multiple model sizes, languages, and output formats over stdio or HTTP.

YouTube Discovery MCP

Enables discovering YouTube videos across multiple languages with personalized recommendations, feedback, and explanation of results, using YouTube Data API v3.

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol (MCP) servers using TypeScript SDK, with example implementations of tools (calculator, greeting) and resources (server info).

mcp-linkedin-post-engager-capture

Enables capturing recent posts from LinkedIn profiles and company pages, including real reaction and comment counts and publicly visible commenters, without requiring a LinkedIn account, cookies, or credentials.

Composer Trade MCP

Enables AI assistants to create, backtest, and manage automated investment strategies (symphonies) on Composer, including searching through 1000+ existing strategies, monitoring portfolio performance, and executing trades with live market data.

local-datasource

将akshare、yfinance、wbgapi、arxiv等免费公开接口封装为4个标准MCP工具，使支持MCP的智能体无需第三方账号和云额度即可直接查询金融市场、宏观经济和学术论文数据。

xhs-image-mcp

Converts text or markdown into Xiaohongshu (Little Red Book) style image cards with AI cover generation, supporting multiple themes and aspect ratios.

playwright-browser-skill

Provides 101 browser automation operations via Playwright, including navigation, interaction, content extraction, network control, and more, integrated with OpenClaw through the MCP protocol.

Zendesk MCP Server (Extended)

A production-grade MCP server for Zendesk that provides ticket management, search, user/group operations, and knowledge base access with support for local stdio and remote HTTP transports, authentication via API keys or OAuth, and multi-tenancy.

coolify-mcp

MCP server for managing Coolify instances, enabling control of applications, databases, services, servers, and more via natural language.

MaxoPerf MCP Server

Remote MCP server enabling AI agents to manage the MaxoPerf performance testing platform via natural language, including creating tests, launching cloud load runs, viewing results, and diagnosing failures.

pageindex-local-mcp

A local-first MCP server for PageIndex — the vectorless, reasoning-based RAG framework. It lets local AI agents index and query local PDF and Markdown documents through a self-hosted PageIndex installation, without requiring any PageIndex cloud API key.

GitHub MCP Server

Stateless Streamable HTTP MCP server exposing 5 GitHub tools (user info, repository metadata, file contents, issue listing, and issue creation) with token-based authentication required only for tool calls.

octo-mcp

Controls Octo Browser antidetect profiles and automates browser tasks through natural language, enabling profile lifecycle management, web scraping, and full browser automation via CDP.

mcp_searxng

MCP server for privacy-respecting web search via SearXNG, providing web, news, and image search with engine listing capabilities.

MCP Control Plane

Open-source, Windows-first control plane for operating local and homelab services through typed MCP servers, featuring 13 servers and 290 tools with infrastructure adapters for Windows, Ubuntu, Docker, and more.

immo-mcp

Analyzes French real-estate market using open data sources like DVF transactions, DPE certificates, and risk data.

Wisp AI Assistant MCP Server

Wisp AI Assistant MCP Server is a local MCP server that gives trusted AI clients read-only desktop context through Wisp: selected text, clipboard contents, active-window details, visible browser-page text, and screen snippets.

mysql-readonly-mcp

A readonly MCP server for MySQL databases that ensures safety by whitelisting only SELECT, SHOW, DESCRIBE, and EXPLAIN statements, with table blacklist support and configurable limits.

LinkedIn MCP Server

Enables natural language interaction with LinkedIn, including profile retrieval, job searching, messaging, and post engagement.

ansim-gil-dongmu

An MCP server that reviews routes for elderly and disabled pedestrians, checking station accessibility and providing safer alternatives.

kingdee_star

Enables read-only access to Kingdee Cloud Star financial data, invoice tax calculation, and generation of reimbursement draft payloads through MCP tools.

PDF Knowledgebase MCP Server

A Model Context Protocol server that enables intelligent document search and retrieval from PDF collections, providing semantic search capabilities powered by OpenAI embeddings and ChromaDB vector storage.