Discover Awesome MCP Servers

Co-Reading MCP

A local MCP server that gives Claude a durable reading room for EPUB and plain text books, enabling chunk-by-chunk navigation, annotations, progress tracking, and shared margin cards.

ucp-mcp-server

Lets AI assistants shop at UCP-enabled merchants through tools for discovery, checkout, discounts, fulfillment, and payment.

Time MCP Server

A Cloudflare Workers-based MCP server that provides current date and time information for any IANA timezone. It enables AI agents to retrieve precise, ISO 8601-formatted timestamps through a globally distributed edge network.

Agent Bridge for Unity

Enables AI agents to control the Unity Editor through MCP, allowing scene building, runtime scripting, visual QA, and more.

MCP Files

Provides a secure, constrained filesystem workspace for LLM agents to manage files, notes, and code artifacts via stdio or remote HTTP. It features granular access controls, including extension whitelisting, storage quotas, and immutable paths for safe automated file operations.

Ghost MCP

Enables AI assistants to manage Ghost CMS content including posts, members, users, tags, tiers, offers, newsletters, invites, roles, and webhooks via the Ghost Admin API.

Universal Agent Economy OS

Foundational MCP/A2A-native core platform for secure credential injection, native x402 micropayments, and Agent-to-Agent routing.

Weather MCP Server

Provides weather forecasts and alerts for US locations using the National Weather Service API. Supports getting detailed forecasts by coordinates and active weather alerts by state code.

Limitless MCP Server

An MCP server that connects Limitless Pendant wearable data to AI tools like Claude and Windsurf, allowing AI assistants to interact with your personal Lifelog recordings through structured tools and searches.

Math-Physics-ML MCP System

Provides GPU-accelerated scientific computing capabilities including symbolic mathematics, quantum wave mechanics simulations, molecular dynamics, and neural network training through four specialized MCP servers.

Tinderbox MCP Server

Một máy chủ MCP để tương tác với công cụ quản lý tri thức Tinderbox.

TinyDB MCP Server

Provides long-term memory for chatbots through a TinyDB-backed MCP server. Enables storing, searching, and managing JSON records with schema validation without requiring external databases.

Semantic D1 MCP

Enables AI-assisted analysis and optimization of Cloudflare D1 databases through comprehensive schema introspection, relationship mapping, validation, and optimization recommendations. Demonstrates semantic intent patterns with hexagonal architecture for maintainable database development workflows.

mcp-sentry

A Model Context Protocol server that enables retrieving and analyzing Sentry issues, including stacktraces and debugging information.

MCP Agent Platform

Một hệ thống tương tác người-máy đa tác tử cho phép tương tác tự nhiên thông qua các khả năng tích hợp nhận dạng hình ảnh, nhận dạng giọng nói và tổng hợp giọng nói.

Grok Image MCP

MCP server for generating and editing images using xAI's Grok image model, supporting text prompts, batch generation, local files, and optional proxy configurations.

MCP Debugger Server

Provides comprehensive debugging capabilities for Node.js and TypeScript applications with 25+ specialized tools, including breakpoint management, variable inspection, hang detection, CPU/memory profiling, and test framework integration.

DatahubMCP

Enables Claude to query MySQL databases and access Google Workspace (Sheets, Forms, Drive) for education program management, with built-in templates for data analysis and report generation.

YApi MCP Server

Enables reading and searching API documentation from YApi instances, allowing AI models to access interface definitions, project API lists, and search through API endpoints using YApi URLs or project IDs.

superman-mcp

A Cursor enhancement plugin that provides multi-session MCP functionality, a membership switcher, and usage billing overview, with no activation code required.

@langapi/mcp-server

MCP server for AI-powered translation management in i18n projects, enabling automated locale detection, translation status checks, and sync via LangAPI.

MySQL MCP Server

A Model Context Protocol server that provides secure, multi-database MySQL access with configurable security levels, enabling SQL queries across multiple databases directly from VS Code.

GitHub MCP Bridge

A Model Context Protocol server that enables AI agents to securely access and interact with GitHub Enterprise data, providing access to enterprise users, organizations, emails, and license information.

AgentShare Price API

AgentShare delivers structured product search and pricing signals for AI agents over REST and MCP (Streamable HTTP). Responses include freshness & coverage metadata so agents can reason about data recency. API keys secure billed endpoints; public discovery at /agent.json and /mcp.json. Currently integrates connected marketplaces and affiliate feeds – roadmap expands to global e-commerce (AliExpre

japan-ux-mcp

Provides Japanese UX conventions as an MCP server to help AI generate correct Japanese UI elements like proper name order, furigana, phone formats, and polite language. It includes tools for form generation, validation, keigo suggestions, and cultural adaptation for developers building Japanese-facing products.

Asta MCP Servers

Provides MCP wrappers for Allen AI's Asta research tools, enabling AI agents to manage local document collections and perform deep literature searches. It supports automated report generation, PDF text extraction, and research hypothesis synthesis.

stock-analyzer-ai-mcp

Analyze stocks with financial ratios, comparisons, and sector performance data.

MCP Template

A template MCP server built with FastMCP framework that demonstrates basic tool implementation with a simple addition calculator example.

Google Calendar MCP Server

Máy chủ Giao thức Bối cảnh Mô hình (MCP) tích hợp với API Lịch Google.

AI Agent with MCP

Okay, here's a basic outline and code snippets to help you create your first MCP (Model Context Protocol) server in a Playground environment. Keep in mind that MCP is a relatively new and evolving protocol, so the specific libraries and implementations might change. This example focuses on a simplified, conceptual approach. **Conceptual Overview** 1. **What is MCP?** MCP is a protocol designed to facilitate communication between a client (e.g., an application needing a model) and a server (hosting the model). It aims to standardize how models are accessed and used, especially in distributed environments. It handles things like: * Model discovery * Model loading/unloading * Model execution (inference) * Data serialization/deserialization 2. **Simplified Approach:** For a Playground, we'll create a very basic server that: * Hosts a simple "model" (in this case, a function that adds two numbers). * Listens for requests on a specific port. * Receives data (two numbers) from a client. * Executes the "model" (adds the numbers). * Sends the result back to the client. **Code (Python - using `socket` for simplicity)** This example uses Python's built-in `socket` library for network communication. While not a full-fledged MCP implementation, it demonstrates the core concepts. ```python import socket import json # --- Model Definition (Simple Addition) --- def add_numbers(a, b): """Our "model" - adds two numbers.""" return a + b # --- Server Configuration --- HOST = '127.0.0.1' # Localhost PORT = 65432 # Port to listen on (choose a free port) # --- Server Logic --- def run_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Server listening on {HOST}:{PORT}") conn, addr = s.accept() with conn: print(f"Connected by {addr}") while True: data = conn.recv(1024) # Receive data (up to 1024 bytes) if not data: break try: # Attempt to decode the data as JSON received_data = json.loads(data.decode('utf-8')) # Check if the data contains 'a' and 'b' keys if 'a' in received_data and 'b' in received_data: a = received_data['a'] b = received_data['b'] # Execute the "model" result = add_numbers(a, b) # Prepare the response response = {'result': result} response_data = json.dumps(response).encode('utf-8') # Send the response back to the client conn.sendall(response_data) print(f"Sent result: {result}") else: error_message = {'error': 'Invalid input format. Expected JSON with keys "a" and "b".'} conn.sendall(json.dumps(error_message).encode('utf-8')) print("Invalid input received.") except json.JSONDecodeError: error_message = {'error': 'Invalid JSON format.'} conn.sendall(json.dumps(error_message).encode('utf-8')) print("Invalid JSON received.") except Exception as e: error_message = {'error': str(e)} conn.sendall(json.dumps(error_message).encode('utf-8')) print(f"Error processing request: {e}") if __name__ == "__main__": run_server() ``` **Explanation:** * **`add_numbers(a, b)`:** This is our placeholder "model." In a real MCP server, this would be a much more complex model (e.g., a TensorFlow or PyTorch model). * **`HOST` and `PORT`:** Configure the server's address and port. `127.0.0.1` is localhost (your own machine). Choose a port that's not commonly used. * **`socket.socket(...)`:** Creates a socket object, which is the endpoint for network communication. * **`s.bind((HOST, PORT))`:** Binds the socket to the specified address and port. * **`s.listen()`:** Starts listening for incoming connections. * **`s.accept()`:** Accepts a connection from a client. This blocks until a client connects. * **`conn.recv(1024)`:** Receives data from the client (up to 1024 bytes at a time). * **`json.loads(data.decode('utf-8'))`:** Decodes the received data, assuming it's a JSON string. We're expecting the client to send a JSON object like `{"a": 5, "b": 3}`. * **`add_numbers(a, b)`:** Executes the "model" with the received data. * **`json.dumps(response).encode('utf-8')`:** Encodes the result back into a JSON string and then encodes it into bytes for sending over the network. * **`conn.sendall(response_data)`:** Sends the response back to the client. * **Error Handling:** Includes `try...except` blocks to handle potential errors like invalid JSON or other exceptions during processing. Sends error messages back to the client. **Client Code (Python)** ```python import socket import json 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)) # Prepare the data to send (as a JSON string) data = {'a': 10, 'b': 5} json_data = json.dumps(data).encode('utf-8') s.sendall(json_data) print(f"Sent: {data}") received_data = s.recv(1024) try: response = json.loads(received_data.decode('utf-8')) print(f"Received: {response}") if 'result' in response: print(f"Result: {response['result']}") elif 'error' in response: print(f"Error: {response['error']}") else: print("Unexpected response format.") except json.JSONDecodeError: print("Received invalid JSON from server.") ``` **Explanation of Client Code:** * **`s.connect((HOST, PORT))`:** Connects to the server. * **`data = {'a': 10, 'b': 5}`:** Creates a dictionary containing the input data for the "model." * **`json.dumps(data).encode('utf-8')`:** Converts the dictionary to a JSON string and then encodes it into bytes. * **`s.sendall(json_data)`:** Sends the data to the server. * **`s.recv(1024)`:** Receives the response from the server. * **`json.loads(received_data.decode('utf-8'))`:** Decodes the JSON response. * **Prints the result or error message.** **How to Run in a Playground (e.g., Google Colab, Jupyter Notebook):** 1. **Run the Server Code:** Copy and paste the server code into a cell in your Playground and run it. It will start listening for connections. **Important:** The server will block at `s.accept()` until a client connects. 2. **Run the Client Code:** Copy and paste the client code into *another* cell in your Playground and run it. The client will connect to the server, send the data, and receive the result. **Important Considerations and Next Steps:** * **Threading/Asynchronous Operations:** The server code above is single-threaded. It can only handle one client at a time. For a real-world MCP server, you'll need to use threading or asynchronous programming (e.g., `asyncio` in Python) to handle multiple concurrent requests. * **Serialization:** MCP often uses more efficient serialization formats than JSON (e.g., Protocol Buffers, Apache Arrow). Consider using these for better performance. * **Model Management:** A real MCP server needs to handle model loading, unloading, versioning, and potentially model discovery. * **Security:** For production environments, you'll need to add security measures (e.g., authentication, authorization, encryption). * **Error Handling:** Implement robust error handling and logging. * **MCP Libraries:** Look for existing MCP libraries or frameworks in your language of choice. These will provide a more complete and standardized implementation of the protocol. However, as of late 2024, MCP is still relatively new, so library support might be limited. You might need to build parts of the protocol yourself. * **gRPC:** gRPC is a popular framework for building high-performance, language-agnostic RPC (Remote Procedure Call) systems. While not strictly MCP, it shares many of the same goals and can be a good alternative or a building block for an MCP-like system. **Example Output (in the Playground):** **Server Output:** ``` Server listening on 127.0.0.1:65432 Connected by ('127.0.0.1', <some_port_number>) Sent result: 15 ``` **Client Output:** ``` Sent: {'a': 10, 'b': 5} Received: {'result': 15} Result: 15 ``` This basic example provides a starting point for understanding the core concepts of an MCP server. To build a production-ready MCP server, you'll need to address the considerations mentioned above and potentially use more specialized libraries and frameworks. Remember to install any necessary libraries (like `protobuf` if you choose to use Protocol Buffers) using `pip install <library_name>` in your Playground environment.