Discover Awesome MCP Servers

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.

docsonar

A local document search MCP server that indexes folders and provides hybrid keyword+semantic search, enabling users to chat with their documents via MCP clients like Claude Desktop or Claude Code.

codex3d

Enables natural language creation and refinement of Blender scenes through structured MCP tools, with persistent object identity, visual validation, and reversible edits.

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

suggest-skills

An MCP server that generates skill manifests from GitHub skills directories and provides tools to recommend and download AI agent skills.

gpt-image-mcp

An MCP server that enables Claude Code and Claude Desktop to generate and edit images using OpenAI's gpt-image-2 model, with results saved to disk.

email-send

Enables sending transactional emails with text or HTML body, delivery status, and message ID via Resend. Pay-per-call using x402 micropayments (USDC on Base L2), no API key or signup required.

protonmail-mcp

Enables AI clients to interact with ProtonMail accounts through the Proton Bridge using SMTP and IMAP protocols. Provides email management capabilities via secure local bridge connections.

LimaCharlie MCP

A local MCP server for the LimaCharlie security platform that provides investigation, administration, and content-review workflows via a broad read-only tool surface with explicit organization scoping and audit logging.

Paylocity MCP Server

Connects Claude Desktop to the Paylocity API to manage employee records, pay statements, and company headcount data through natural language. It includes automated data protection that redacts sensitive information like SSNs and bank account numbers before reaching the model.

Xiaohongshu (XHS) Creator Toolkit

An automation toolkit that enables AI-driven content publishing and creator data analysis for Xiaohongshu via the MCP protocol. It supports automated posting of image and video notes, cookie management, and performance metric tracking through natural language conversations.

acmt001-mcp

MCP server for ISO 20022 acmt.001 Account Opening (and companion acmt.* messages): message-type discovery, required-field lookup, JSON Schema introspection, IBAN/BIC/LEI validation, flat-record validation, and validated acmt XML generation.

Knowledge Graph Builder

Transforms text or web content into structured knowledge graphs using local AI models with MCP integration for persistent storage in Neo4j and Qdrant.

MCP Notion Server (@suncreation)

An MCP server that enables LLMs to interact with Notion workspaces via the Notion API, supporting page creation, database management, and content retrieval. It features markdown conversion to optimize token usage and enhanced error handling for more reliable workspace interactions.

RadMail MCP

An email operating system for AI agents that provides safe triage, drafting, and searching of emails with unbypassable hard-stops on money, banking changes, first-contact senders, and prompt injection.

Parakeet Transcription MCP Server

Transcribes audio/video files to text using NVIDIA's Parakeet TDT 0.6B V2 model, with optional timestamps; also retrieves model and system hardware info.

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

Server Model Context Protocol (MCP) yang terintegrasi dengan Google Calendar API

textview-mcp

Connects AI assistants to TextView for persistent memory, enabling saving, searching, and retrieving notes across sessions.

Odoo 19 MCP Server

Provides tools to interact with Odoo 19's External JSON-2 API, enabling CRUD operations and complex queries on Odoo databases with multi-company support.

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 server. **Conceptual Overview** The Model Context Protocol (MCP) is designed to allow clients to request information about a model's context. This context can include things like: * **Model Metadata:** Information about the model itself (e.g., name, version, description). * **Input Schema:** The expected format of input data for the model. * **Output Schema:** The format of the model's output. * **Vocabulary:** The set of allowed values for certain input fields (e.g., a list of valid categories). * **Constraints:** Rules or limitations on the input data (e.g., a range for a numerical value). **Simplified Example (Python with Flask)** This example uses Python and the Flask web framework to create a simple MCP server. It's a very basic illustration and doesn't implement the full MCP specification. It focuses on providing a model's input schema. ```python from flask import Flask, jsonify app = Flask(__name__) # Define the model's input schema model_input_schema = { "type": "object", "properties": { "text_input": { "type": "string", "description": "The text to be processed by the model." }, "category": { "type": "string", "description": "The category of the text.", "enum": ["news", "sports", "finance"] # Example vocabulary }, "confidence_threshold": { "type": "number", "description": "Minimum confidence score required.", "minimum": 0.0, "maximum": 1.0 } }, "required": ["text_input"] } @app.route("/.well-known/model-context", methods=['GET']) def get_model_context(): """ This endpoint returns the model's context information. In a real MCP server, this would be more comprehensive. """ context = { "model_name": "MyTextClassifier", "model_version": "1.0", "description": "A simple text classification model.", "input_schema": model_input_schema } return jsonify(context) if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Make accessible in Playground ``` **Explanation:** 1. **Import Libraries:** Imports `Flask` for creating the web server and `jsonify` for converting Python dictionaries to JSON. 2. **Create Flask App:** `app = Flask(__name__)` creates a Flask application instance. 3. **Define `model_input_schema`:** This dictionary represents the input schema for your model. It uses JSON Schema-like syntax to describe the expected input fields, their types, descriptions, and constraints. * `type`: Specifies the data type (e.g., "string", "number", "object"). * `properties`: A dictionary where keys are the names of the input fields and values are the schema for each field. * `description`: A human-readable description of the field. * `enum`: A list of allowed values (for vocabulary). * `minimum`, `maximum`: Constraints for numerical values. * `required`: A list of fields that are mandatory. 4. **`/.well-known/model-context` Endpoint:** * `@app.route("/.well-known/model-context", methods=['GET'])`: This decorator defines a route (URL endpoint) for the server. The `/.well-known/model-context` path is a convention for MCP servers. It specifies that this endpoint should handle HTTP GET requests. * `get_model_context()`: This function is called when a client makes a GET request to the `/model-context` endpoint. * `context`: A dictionary containing the model's context information. In this example, it includes the model name, version, description, and the `input_schema`. * `return jsonify(context)`: Converts the `context` dictionary to a JSON response and sends it back to the client. 5. **`if __name__ == '__main__':`:** This ensures that the Flask app is only run when the script is executed directly (not when it's imported as a module). * `app.run(debug=True, host='0.0.0.0', port=5000)`: Starts the Flask development server. * `debug=True`: Enables debugging mode (useful for development). * `host='0.0.0.0'`: Makes the server accessible from outside the local machine (important for Playground environments). * `port=5000`: Specifies the port number the server will listen on. **How to Run in a Playground (e.g., Google Colab):** 1. **Install Flask:** If you're using a Playground environment like Google Colab, you might need to install Flask first: ```bash !pip install flask ``` 2. **Copy and Paste the Code:** Copy the Python code above into a code cell in your Playground. 3. **Run the Code Cell:** Execute the code cell. The Flask server will start running. 4. **Access the Endpoint:** The Playground environment will usually provide a URL where your server is accessible. It might look something like `https://your-playground-url.com/`. To access the model context, you would open the following URL in your browser or use a tool like `curl`: ``` https://your-playground-url.com/.well-known/model-context ``` You should see a JSON response containing the model's context information (including the input schema). **Important Considerations and Next Steps:** * **Error Handling:** Add error handling to your server to gracefully handle invalid requests or unexpected situations. * **Security:** For production environments, implement proper security measures (authentication, authorization, etc.). * **MCP Specification:** Refer to the official Model Context Protocol specification (if available) for the most up-to-date details on the protocol's requirements and best practices. The specification will define the exact format of the context information and the required endpoints. * **More Complex Schemas:** Explore more advanced JSON Schema features to define more complex input and output schemas, including nested objects, arrays, and validation rules. * **Vocabulary Management:** Implement a mechanism for managing and updating the vocabularies used in your model's input schema. * **Integration with Model Serving:** Integrate your MCP server with your model serving infrastructure so that clients can easily discover and understand the models they are interacting with. * **Frameworks and Libraries:** Look for existing Python libraries or frameworks that might provide more comprehensive support for MCP. (As MCP is relatively new, the ecosystem is still developing.) **Example Client (Python):** Here's a simple Python client to fetch the model context: ```python import requests url = "http://your-playground-url.com/.well-known/model-context" # Replace with your server's URL try: response = requests.get(url) response.raise_for_status() # Raise an exception for bad status codes context = response.json() print(context) except requests.exceptions.RequestException as e: print(f"Error: {e}") ``` **Key Improvements and Considerations for a Real MCP Server:** * **Standardized Context Format:** Adhere to a well-defined and standardized format for the model context information. This might involve using a specific schema language or data serialization format. * **Versioning:** Support versioning of the model context so that clients can request the context for a specific version of the model. * **Discovery:** Provide a mechanism for clients to discover the available models and their corresponding context endpoints. * **Dynamic Context:** Allow the model context to be updated dynamically as the model evolves. * **Authentication and Authorization:** Implement security measures to protect the model context from unauthorized access. * **Scalability:** Design the server to handle a large number of concurrent requests. This example provides a starting point for building your own MCP server. Remember to consult the official MCP documentation and adapt the code to your specific needs. Good luck!

hybrid-rag-mcp

An MCP server that provides a search_docs tool with hybrid retrieval (BM25 + dense vectors) and cross-encoder reranking, backed by evaluation, prompt-injection guardrails, and OpenTelemetry tracing.

mcp-funcheap

Enables querying San Francisco Bay Area events from Funcheap, including event details, tags, and categories.

macos-mcp

Local MCP server for macOS native apps: Mail, Calendar, Reminders, Notes, Messages, and Contacts. Enables reading and organizing your Mac life through a single stdio process using AppleScript/JXA.

neurodivergent-memory

MCP server for knowledge graphs designed around neurodivergent thinking patterns, organizing memories into five districts with BM25 ranking and bidirectional connections.

laptop-care

A laptop maintenance agent for Claude Desktop that inspects your machine, explains findings, recommends actions, and remembers history, with safety gates enforced by the server.

@langapi/mcp-server

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

Gluestack Components MCP Server

Enables integration of Gluestack components with Claude Desktop and Cursor IDE for UI development.

Basic MCP

A simple MCP server built with FastMCP for experimentation and learning purposes. Includes basic web tools like article fetching and serves as a human-readable template for building custom MCP servers.