Discover Awesome MCP Servers

mcp-email

Self-hosted MCP server for any IMAP/SMTP inbox. Multi-account in one config. Built for Claude Code.

Black Orchid

A hot-reloadable MCP proxy server that enables users to create and manage custom Python tools through dynamic module loading. Users can build their own utilities, wrap APIs, and extend functionality by simply adding Python files to designated folders.

codex-antigravity-bridge

Enables MCP-compatible clients like Codex to delegate tasks to the Antigravity CLI, using ConPTY on Windows to reliably capture responses.

omnicall-mcp

Keyless, pay-per-call AI gateway: 248 LLMs plus image/video/voice/music generation and live crypto, DeFi, markets, web-search and research tools through one MCP server. Pay per call in USDC via x402 on Base/Solana — no API key, no signup, free tier.

mindnode-mcp

Enables reading and writing MindNode mind maps directly by parsing their on-disk format, without AppleScript or Shortcuts.

bunpro-mcp

An unofficial MCP server for Bunpro that exposes its review queue, search, statistics, and SRS management as tools, enabling an LLM agent to read study data and add grammar points or vocabulary to reviews.

tldraw MCP

Enables AI agents to read, write, and search local tldraw (.tldr) files, providing a persistent visual scratchpad for diagramming and note organization. It supports full CRUD operations on canvas shapes and metadata management for local canvas files.

smart-dom

Token-efficient browser automation for AI agents, filtering the DOM to only interactive elements and grouping them by page section, reducing token usage by 3-13x compared to Playwright MCP.

Arcane MCP

Enables AI assistants to manage Docker containers, images, volumes, networks, and compose projects through Arcane's API. Provides comprehensive tools for environment, container, image, volume, network, project, and system operations.

Sentry Issues MCP

Sebuah server yang memungkinkan pengambilan isu Sentry melalui dua alat sederhana - mendapatkan isu spesifik berdasarkan URL/ID atau mendapatkan daftar isu dari sebuah proyek.

PostgreSQL MCP Server

Full-featured MCP server that exposes 36 tools for interacting with PostgreSQL databases, covering schema introspection, query execution, data exploration, performance monitoring, security auditing, and maintenance.

Agent Room

A multi-agent collaboration layer for AI coding agents enabling real-time communication, code review, and task handoff across distributed development sessions.

Snip

Screenshot and diagram tool for AI agents. Capture and annotate screenshots to show Claude what you mean — or let the agent render Mermaid diagrams and open them for visual review. Approve, annotate, or request changes with text feedback. Built-in review mode with structured responses. CLI and MCP server for Claude Code, Cursor, Windsurf, Cline. macOS, open source, free.

MariaDB MCP Server

Enables querying local MariaDB and MySQL databases with optimized output formats designed to significantly reduce token consumption. It provides secure tools for exploring schemas and executing read-only SQL queries while automatically blocking destructive commands.

Fastmail MCP Server

Enables reading and searching Fastmail inbox emails, including listing inbox emails, querying by keyword, and retrieving email content via JMAP.

Seedream MCP Server

Wraps ByteDance Seedream text-to-image model as an MCP tool, enabling Claude to generate images from natural language prompts.

COBOL Bridge MCP Server

Connects legacy COBOL mainframe systems to modern AI governance via MCP, with tools for parsing copybooks, assessing CICS, scanning JCL, mapping VSAM, and translating EBCDIC.

personal-mail-mcp

A local MCP server that connects Codex to Microsoft Graph and Gmail for reading and managing personal mail and calendar accounts.

MCP Neurolora

An intelligent MCP server that provides tools for code analysis using OpenAI API, code collection, and documentation generation.

mcp-altegio

MCP server for Altegio API — appointments, clients, services, staff schedules

Stripe MCP Server

Enables Claude to integrate with Stripe for creating payment links, processing payments, and managing products and customers.

database-updater MCP Server

Cermin dari

wg21-wiki-mcp

A local MCP server that gives an LLM agent read access to the WG21 (ISO C++) committee wiki as a verifiable source of truth, requiring authentication and providing exact wikitext with provenance.

GitHub Integration Hub

Enables AI agents to interact with GitHub through OAuth-authenticated operations including starting authorization flows, listing repositories, and creating issues using stored access tokens.

MCP Server Proxy

Aggregates multiple MCP servers into a single endpoint, enabling LLM clients to access tools, resources, and prompts from various backends through one connection.

literature-agent-mcp

Exposes a local biomedical literature pipeline as MCP tools for automated research workflows. Enables literature search, open-access paper retrieval, and draft generation for biomedical and pathology domains through standard MCP clients.

Aws Sample Gen Ai Mcp Server

Okay, here's a sample code snippet demonstrating how to use Gen-AI (specifically, Bedrock) with an MCP (Message Communication Protocol) server in Python. This example assumes you have: 1. **AWS Credentials Configured:** Your AWS credentials (access key, secret key, region) are properly configured, either through environment variables, an IAM role, or the AWS CLI. 2. **Bedrock Access:** You have access to the Bedrock service and the specific model you want to use (e.g., Anthropic Claude, AI21 Labs Jurassic-2). 3. **MCP Server Running:** You have an MCP server running and listening for connections. The example uses a simple TCP socket for the MCP communication. You'll need to adapt the MCP server part to your specific MCP implementation. 4. **Libraries Installed:** You have the necessary libraries installed: `boto3`, `json`. ```python import boto3 import json import socket # Configuration BEDROCK_REGION = "us-east-1" # Replace with your Bedrock region MODEL_ID = "anthropic.claude-v2" # Replace with your desired Bedrock model ID MCP_SERVER_HOST = "localhost" # Replace with your MCP server host MCP_SERVER_PORT = 12345 # Replace with your MCP server port # Initialize Bedrock client bedrock = boto3.client(service_name="bedrock-runtime", region_name=BEDROCK_REGION) def generate_text_with_bedrock(prompt): """ Generates text using the Bedrock service. Args: prompt (str): The prompt to send to the model. Returns: str: The generated text, or None if there was an error. """ try: # Construct the request body based on the model if "anthropic" in MODEL_ID: body = json.dumps({ "prompt": f"\n\nHuman: {prompt}\n\nAssistant:", "max_tokens_to_sample": 200, # Adjust as needed "temperature": 0.5, # Adjust as needed "top_p": 0.9, # Adjust as needed }) content_type = "application/json" accept = "application/json" elif "ai21" in MODEL_ID: body = json.dumps({ "prompt": prompt, "maxTokens": 200, "temperature": 0.7, "topP": 1, "stopSequences": [] }) content_type = "application/json" accept = "application/json" else: print(f"Unsupported model ID: {MODEL_ID}") return None response = bedrock.invoke_model( modelId=MODEL_ID, contentType=content_type, accept=accept, body=body ) response_body = json.loads(response["body"].read().decode("utf-8")) # Extract the generated text based on the model if "anthropic" in MODEL_ID: generated_text = response_body["completion"] elif "ai21" in MODEL_ID: generated_text = response_body["completions"][0]["data"]["text"] else: return None return generated_text.strip() except Exception as e: print(f"Error generating text: {e}") return None def handle_mcp_request(client_socket): """ Handles a request received from the MCP server. Args: client_socket (socket): The socket connected to the client. """ try: # Receive data from the MCP server request_data = client_socket.recv(1024).decode("utf-8") # Adjust buffer size as needed if not request_data: print("No data received from MCP server.") return print(f"Received from MCP server: {request_data}") # Assuming the MCP request is a JSON string containing a "prompt" field try: request_json = json.loads(request_data) prompt = request_json.get("prompt") if not prompt: response_message = json.dumps({"error": "Missing 'prompt' field in request."}) client_socket.sendall(response_message.encode("utf-8")) return except json.JSONDecodeError: response_message = json.dumps({"error": "Invalid JSON format in request."}) client_socket.sendall(response_message.encode("utf-8")) return # Generate text using Bedrock generated_text = generate_text_with_bedrock(prompt) if generated_text: # Construct the response message response_message = json.dumps({"response": generated_text}) else: response_message = json.dumps({"error": "Failed to generate text."}) # Send the response back to the MCP server client_socket.sendall(response_message.encode("utf-8")) print(f"Sent to MCP server: {response_message}") except Exception as e: print(f"Error handling MCP request: {e}") error_message = json.dumps({"error": str(e)}) client_socket.sendall(error_message.encode("utf-8")) finally: client_socket.close() def main(): """ Main function to listen for connections from the MCP server. """ server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((MCP_SERVER_HOST, MCP_SERVER_PORT)) server_socket.listen(1) # Listen for only one connection at a time (for simplicity) print(f"Listening for MCP server connections on {MCP_SERVER_HOST}:{MCP_SERVER_PORT}") while True: try: client_socket, address = server_socket.accept() print(f"Accepted connection from {address}") handle_mcp_request(client_socket) except KeyboardInterrupt: print("Shutting down server.") break except Exception as e: print(f"Error in main loop: {e}") server_socket.close() if __name__ == "__main__": main() ``` **Explanation:** 1. **Imports:** Imports necessary libraries: `boto3` for Bedrock, `json` for handling JSON data, and `socket` for MCP communication. 2. **Configuration:** Sets configuration variables for the Bedrock region, model ID, MCP server host, and port. **Important:** Replace these with your actual values. 3. **`generate_text_with_bedrock(prompt)`:** * Takes a `prompt` as input. * Constructs the request body for the Bedrock `invoke_model` API call. **Crucially, the format of the request body depends on the specific Bedrock model you're using.** The example shows how to format the request for Anthropic Claude and AI21 Labs Jurassic-2. Refer to the Bedrock documentation for the correct format for other models. * Calls `bedrock.invoke_model()` to send the request to Bedrock. * Parses the response from Bedrock and extracts the generated text. **Again, the format of the response depends on the model.** * Handles potential errors and returns the generated text or `None` if there was an error. 4. **`handle_mcp_request(client_socket)`:** * Receives data from the MCP server using `client_socket.recv()`. * Assumes the data is a JSON string containing a `prompt` field. Parses the JSON and extracts the prompt. Handles potential JSON decoding errors. * Calls `generate_text_with_bedrock()` to generate text using Bedrock. * Constructs a JSON response message containing either the generated text or an error message. * Sends the response back to the MCP server using `client_socket.sendall()`. * Closes the client socket. 5. **`main()`:** * Creates a TCP socket and binds it to the specified host and port. * Listens for incoming connections from the MCP server. * When a connection is accepted, calls `handle_mcp_request()` to handle the request. * Handles `KeyboardInterrupt` to allow the server to be shut down gracefully. **How to Use:** 1. **Install Libraries:** ```bash pip install boto3 ``` 2. **Configure AWS Credentials:** Make sure your AWS credentials are set up correctly. 3. **Start the MCP Server:** Start your MCP server and make sure it's listening on the specified host and port. The MCP server needs to be able to send JSON requests to this Python script. 4. **Run the Python Script:** Run the Python script. It will listen for connections from the MCP server. 5. **Send Requests from the MCP Server:** Send JSON requests to the Python script from your MCP server. The requests should have the following format: ```json { "prompt": "Write a short story about a cat who goes on an adventure." } ``` **Important Considerations:** * **Error Handling:** The code includes basic error handling, but you should add more robust error handling for production use. Consider logging errors to a file or using a more sophisticated error reporting system. * **Security:** If your MCP server is exposed to the internet, you need to implement proper security measures to protect it from unauthorized access. * **Scalability:** This example is a simple single-threaded server. For production use, you'll likely need to use a multi-threaded or asynchronous server to handle multiple requests concurrently. Consider using a framework like `asyncio` or `threading` for this. * **MCP Protocol:** This example assumes a very simple MCP protocol where the request is a JSON string. You'll need to adapt the code to your specific MCP protocol. * **Bedrock Model Parameters:** Experiment with the parameters in the `generate_text_with_bedrock` function (e.g., `max_tokens_to_sample`, `temperature`, `top_p`) to get the desired results from the Bedrock model. Refer to the Bedrock documentation for details on these parameters. * **Model-Specific Code:** The code includes model-specific logic for Anthropic Claude and AI21 Labs Jurassic-2. You'll need to add similar logic for other Bedrock models you want to use. **Always consult the Bedrock documentation for the specific model you're using.** * **Rate Limiting:** Be aware of the rate limits for the Bedrock service. You may need to implement rate limiting in your code to avoid exceeding the limits. * **Cost:** Using Bedrock incurs costs. Be sure to monitor your AWS usage and costs. This example provides a starting point for integrating Gen-AI (Bedrock) with an MCP server. You'll need to adapt it to your specific requirements and environment.

Universal Crypto MCP

Enables AI agents to interact with any EVM-compatible blockchain through natural language, supporting token swaps, cross-chain bridges, staking, lending, governance, gas optimization, and portfolio tracking across networks like Ethereum, BSC, Polygon, Arbitrum, and more.

DesignBot MCP

Forwards messages to the Designsystemet assistant endpoint, enabling access through MCP-compatible clients.

DOMShell

MCP server that turns your browser into a filesystem. 38 tools let AI agents ls, cd, grep, click, and type through Chrome via the DOMShell extension.