Discover Awesome MCP Servers

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

Flutter MCP Server

A TypeScript-based MCP server that implements a simple notes system, enabling users to manage text notes with creation and summarization functionalities through structured prompts.

python-devtools

Enables live runtime inspection of any Python application, allowing MCP clients to query state, evaluate expressions, inspect objects, and read source code while the app runs.

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.

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.

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.

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

モデルコンテキストプロトコル (MCP) サーバー (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. This will be a simplified example to get you started. Keep in mind that a full MCP implementation can be quite complex depending on the features you want to support. **Conceptual Overview** The Model Context Protocol (MCP) is a protocol that allows a client (e.g., a code editor, IDE, or other tool) to interact with a language server or other process that provides information about a code model. It's similar in spirit to the Language Server Protocol (LSP), but often focuses on more general model information rather than just language-specific features. **Simplified Example Structure** For this Playground example, we'll create a very basic server that responds to a single request: 1. **Client Request:** The client sends a request to the server asking for information about a specific "model element" (e.g., a variable, function, class). We'll represent this with a simple string identifier. 2. **Server Processing:** The server receives the request, looks up information about the model element (in our case, from a hardcoded dictionary), and sends a response back to the client. 3. **Client Response:** The client receives the response and displays the information. **Playground Code (Swift)** ```swift import Foundation // 1. Define the data structures struct MCPRequest: Codable { let elementId: String } struct MCPResponse: Codable { let elementId: String let description: String } // 2. Simulated Model Data (Replace with your actual model) let modelData: [String: String] = [ "myVariable": "This is a variable that stores an integer.", "myFunction": "This is a function that calculates the square of a number.", "MyClass": "This is a class that represents a user.", "anotherVariable": "This is another variable used for counting." ] // 3. Server Logic (Simplified) func handleRequest(requestData: Data) -> Data? { do { let decoder = JSONDecoder() let request = try decoder.decode(MCPRequest.self, from: requestData) guard let description = modelData[request.elementId] else { print("Element not found: \(request.elementId)") return nil // Or return an error response } let response = MCPResponse(elementId: request.elementId, description: description) let encoder = JSONEncoder() return try encoder.encode(response) } catch { print("Error decoding/encoding: \(error)") return nil // Or return an error response } } // 4. Simulate Client-Server Communication (in the same Playground) // Simulate a client request let clientRequest = MCPRequest(elementId: "myFunction") do { let encoder = JSONEncoder() let requestData = try encoder.encode(clientRequest) // Simulate sending the request to the server (in reality, this would be over a network connection) if let responseData = handleRequest(requestData: requestData) { let decoder = JSONDecoder() let response = try decoder.decode(MCPResponse.self, from: responseData) print("Received response for element: \(response.elementId)") print("Description: \(response.description)") } else { print("No response received or error occurred.") } } catch { print("Error creating request: \(error)") } // Example of a request for a non-existent element let clientRequest2 = MCPRequest(elementId: "nonExistentElement") do { let encoder = JSONEncoder() let requestData = try encoder.encode(clientRequest2) // Simulate sending the request to the server (in reality, this would be over a network connection) if let responseData = handleRequest(requestData: requestData) { let decoder = JSONDecoder() let response = try decoder.decode(MCPResponse.self, from: responseData) print("Received response for element: \(response.elementId)") print("Description: \(response.description)") } else { print("No response received or error occurred for non-existent element.") } } catch { print("Error creating request: \(error)") } ``` **Explanation:** 1. **Data Structures:** `MCPRequest` and `MCPResponse` define the structure of the messages exchanged between the client and server. They use `Codable` to make it easy to serialize and deserialize them to/from JSON. 2. **Model Data:** `modelData` is a dictionary that simulates your code model. In a real application, this would be replaced with a more sophisticated representation of your code. 3. **`handleRequest` Function:** This function is the core of the server. It receives the request data, decodes it, looks up the information in `modelData`, creates a response, encodes it, and returns the response data. Error handling is included. 4. **Client Simulation:** The code simulates a client sending a request to the server and receiving the response. In a real application, this would involve network communication (e.g., using sockets or a framework like `NIO`). **How to Run:** 1. Open Xcode. 2. Create a new Playground (File -> New -> Playground). 3. Copy and paste the code into the Playground. 4. Run the Playground (Shift + Command + Enter). **Important Considerations and Next Steps:** * **Network Communication:** This example uses in-memory communication. To create a real server, you'll need to use sockets or another networking mechanism to allow clients to connect to the server. Consider using SwiftNIO for asynchronous network handling. * **Error Handling:** The error handling in this example is basic. You should implement more robust error handling, including sending error responses to the client. * **Model Representation:** The `modelData` dictionary is a very simple representation of a code model. In a real application, you'll need a more sophisticated data structure to represent the code, including information about types, scopes, relationships between elements, etc. Consider using a graph database or a custom data structure. * **Request Types:** This example only handles one type of request. You'll need to define different request types for different operations (e.g., getting the type of a variable, finding all references to a function, etc.). * **Asynchronous Operations:** Many operations in a language server can be time-consuming (e.g., parsing code, performing static analysis). You should use asynchronous operations to avoid blocking the server's main thread. * **Concurrency:** If you want to handle multiple client requests concurrently, you'll need to use concurrency mechanisms (e.g., threads, dispatch queues, actors). * **JSON RPC:** MCP often uses JSON RPC as the underlying communication protocol. Consider using a library that provides JSON RPC support. * **Real-World MCP Implementations:** Look at existing MCP implementations (if any are publicly available) for inspiration. The Language Server Protocol (LSP) is a good starting point, as MCP is often inspired by it. **Example using SwiftNIO (Illustrative - Requires Setup)** This is a very basic example to show how you *might* use SwiftNIO. You'll need to add SwiftNIO as a dependency to your project (using Swift Package Manager). This code *won't* run directly in a Playground without extra setup. ```swift // **This is illustrative and requires SwiftNIO setup** import NIO import NIOFoundationCompat // ... (MCPRequest, MCPResponse, modelData, handleRequest from above) class MCPHandler: ChannelInboundHandler { typealias InboundIn = ByteBuffer typealias OutboundOut = ByteBuffer func channelRead(context: ChannelHandlerContext, data: NIOAny) { var buffer = self.unwrapInboundIn(data) let requestData = Data(buffer: buffer) if let responseData = handleRequest(requestData: requestData) { var responseBuffer = context.channel.allocator.buffer(capacity: responseData.count) responseBuffer.writeBytes(responseData) context.writeAndFlush(self.wrapOutboundOut(responseBuffer), promise: nil) } else { // Handle error (e.g., send an error response) print("Error handling request") } } func channelReadComplete(context: ChannelHandlerContext) { context.flush() } func errorCaught(context: ChannelHandlerContext, error: Error) { print("error: ", error) context.close(promise: nil) } } let group = MultiThreadedEventLoopGroup(numberOfThreads: 1) // Or more threads let bootstrap = ServerBootstrap(group: group) // Specify backlog and enable SO_REUSEADDR for the server itself .serverChannelOption(ChannelOptions.backlog, value: 256) .serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1) // Set the handlers that are applied to the accepted Channels .childChannelInitializer { channel in channel.pipeline.addHandler(MCPHandler()) } // Enable SO_REUSEADDR for the accepted Channels .childChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1) .childChannelOption(ChannelOptions.maxMessagesPerRead, value: 16) .childChannelOption(ChannelOptions.recvAllocator, value: AdaptiveRecvByteBufferAllocator()) defer { try! group.syncShutdownGracefully() } do { let channel = try bootstrap.bind(host: "localhost", port: 8888).wait() print("Server started and listening on \(channel.localAddress!)") // This will block. try channel.closeFuture.wait() } catch { fatalError("Failed to start server: \(error)") } ``` **Explanation of SwiftNIO Example:** 1. **`MCPHandler`:** This is a `ChannelInboundHandler` that receives data from the client, processes it using the `handleRequest` function, and sends the response back to the client. 2. **`ServerBootstrap`:** This sets up the server to listen for incoming connections. 3. **Event Loop Group:** SwiftNIO uses an event loop group to handle asynchronous operations. 4. **Binding:** The `bind` function starts the server listening on a specific host and port. **To use the SwiftNIO example:** 1. Create a new Xcode project (not a Playground). 2. Add SwiftNIO as a dependency using Swift Package Manager (File -> Add Packages...). 3. Copy and paste the code into your project. 4. Run the project. You would then need to write a client application (also using SwiftNIO or another networking library) to connect to the server and send requests. This is a complex topic, and this is just a starting point. Good luck! Remember to break down the problem into smaller, manageable steps.

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.

@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.