Discover Awesome MCP Servers

EMMA MCP

A custom MCP server that enables Claude to access and query municipal bond data from the MSRB's EMMA website, which lacks a public API. It provides 18 tools for searching bonds, downloading official statements, and extracting financial data through natural language prompts.

Prefeitura PE Recife: CPOM

Enables querying official data from the Prefeitura de Recife (Recife City Hall) through a hosted, read-only MCP server. Supports MCP over HTTP with usage-based prepaid billing.

carly-cli

Agent-native MCP server for Carly, the AI scheduling assistant. Exposes 11 tools to read and manage booking pages, event types, calendars, bookings, and available slots. Allows you to manage and create booking pages from the command line.

Jira Prompts MCP Server

Jiraのコンテンツからプロンプトやコンテキストを生成するためのいくつかのコマンドを提供するMCPサーバー

Canvas LMS MCP Server

Enables AI systems to interact with Canvas Learning Management System data, allowing users to access courses, assignments, quizzes, planner items, files, and syllabi through natural language queries.

sui-mcp-server

Comprehensive MCP server for the Sui blockchain with 53 tools covering wallets, DeFi (Cetus, DeepBook), SuiNS, staking, validators, Move introspection, and full RPC. Enables natural language interaction with the entire Sui ecosystem.

MCP Skeleton

A starter template for building Model Context Protocol (MCP) servers with Node.js. It provides a foundational structure and an example tool to help developers quickly scaffold and deploy new MCP capabilities.

gemot

Deliberation primitive for multi-agent coordination — agents submit positions, vote on a 5-point scale, and the server returns crux detection, vote clustering, bridging statements, and consensus. Inspired by Polis and Talk to the City.

Aws Sample Gen Ai Mcp Server

Okay, here's a sample code snippet demonstrating how to use Gen-AI (Bedrock) with an MCP (Message Control Protocol) server. This example focuses on the core concepts and assumes you have the necessary libraries and configurations set up. It's a simplified illustration and will need adaptation based on your specific MCP server and Bedrock use case. **Conceptual Overview** 1. **MCP Server:** This acts as a central point for receiving requests. It could be a simple TCP server or a more sophisticated message queue system. The code below uses a basic TCP server for demonstration. 2. **Bedrock (Gen-AI):** This is where the AI model resides. You'll use the Bedrock API to send prompts and receive responses. 3. **Workflow:** * The MCP server receives a request (e.g., a text prompt). * The server forwards the prompt to Bedrock. * Bedrock processes the prompt and returns a response. * The server sends the response back to the client. **Python Example (using `socket` for MCP and `boto3` for Bedrock)** ```python import socket import boto3 import json # Configuration (replace with your actual values) MCP_HOST = 'localhost' # Or your MCP server's IP address MCP_PORT = 12345 # Or your MCP server's port BEDROCK_REGION = 'us-east-1' # Or your Bedrock region BEDROCK_MODEL_ID = 'anthropic.claude-v2' # Or your desired Bedrock model ID ACCEPTABLE_ORIGINS = ["localhost", "127.0.0.1"] # Add any other acceptable origins here # Initialize Bedrock client bedrock = boto3.client(service_name='bedrock-runtime', region_name=BEDROCK_REGION) def handle_request(client_socket, client_address): """Handles a single request from a client.""" try: data = client_socket.recv(1024).decode('utf-8') if not data: return # Client disconnected print(f"Received from {client_address}: {data}") # Check origin (very basic example - improve this for production!) try: request_json = json.loads(data) origin = request_json.get("origin", None) prompt = request_json.get("prompt", None) except json.JSONDecodeError: print("Invalid JSON received") client_socket.sendall("Invalid JSON".encode('utf-8')) return if origin not in ACCEPTABLE_ORIGINS: print(f"Request from unacceptable origin: {origin}") client_socket.sendall("Origin not allowed".encode('utf-8')) return if not prompt: print("No prompt provided") client_socket.sendall("No prompt provided".encode('utf-8')) return # Call Bedrock try: response = invoke_bedrock(prompt) client_socket.sendall(response.encode('utf-8')) except Exception as e: print(f"Bedrock error: {e}") client_socket.sendall(f"Bedrock error: {e}".encode('utf-8')) except Exception as e: print(f"Error handling request: {e}") finally: client_socket.close() def invoke_bedrock(prompt): """Invokes the Bedrock model with the given prompt.""" # Construct the request body (adjust based on the model) body = json.dumps({ "prompt": prompt, "max_tokens_to_sample": 200, # Adjust as needed "temperature": 0.5, # Adjust as needed "top_p": 0.9 # Adjust as needed }) try: response = bedrock.invoke_model( modelId=BEDROCK_MODEL_ID, contentType='application/json', accept='application/json', body=body ) response_body = json.loads(response['body'].read().decode('utf-8')) completion = response_body['completion'] # Adjust based on model's response format return completion except Exception as e: print(f"Error invoking Bedrock: {e}") return f"Error: {e}" def start_mcp_server(): """Starts the MCP server.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((MCP_HOST, MCP_PORT)) server_socket.listen(5) # Listen for up to 5 incoming connections print(f"MCP server listening on {MCP_HOST}:{MCP_PORT}") while True: client_socket, client_address = server_socket.accept() print(f"Accepted connection from {client_address}") handle_request(client_socket, client_address) # Handle the request in a separate function if __name__ == "__main__": start_mcp_server() ``` **Explanation:** * **Imports:** Imports necessary libraries (`socket`, `boto3`, `json`). * **Configuration:** Sets up configuration variables for the MCP server address, port, Bedrock region, and model ID. **Crucially, replace these with your actual values.** * **`handle_request()`:** * Receives data from the client socket. * Decodes the data (assuming UTF-8 encoding). * **Important:** Includes a very basic origin check. **This is a placeholder and needs to be significantly improved for any production environment.** You should implement robust authentication and authorization. The example expects a JSON payload with `origin` and `prompt` fields. * Calls `invoke_bedrock()` to send the prompt to Bedrock. * Sends the response back to the client. * Handles potential errors. * Closes the client socket. * **`invoke_bedrock()`:** * Constructs the request body for the Bedrock API. **This is highly model-dependent.** The example shows a basic structure for Anthropic Claude. You'll need to consult the Bedrock documentation for the specific model you're using to determine the correct request format. * Calls the `bedrock.invoke_model()` method. * Parses the response from Bedrock. **Again, the response format is model-dependent.** The example assumes a `completion` field in the response. * Handles potential errors. * **`start_mcp_server()`:** * Creates a TCP socket. * Binds the socket to the specified host and port. * Listens for incoming connections. * Accepts connections in a loop. * Calls `handle_request()` to process each connection. * **`if __name__ == "__main__":`:** Starts the MCP server when the script is run. **How to Run:** 1. **Install Libraries:** ```bash pip install boto3 ``` 2. **Configure AWS Credentials:** Make sure you have configured your AWS credentials (e.g., using `aws configure` or environment variables) so that `boto3` can access Bedrock. The IAM role or user you're using must have permissions to invoke the Bedrock model. 3. **Replace Placeholders:** Update the configuration variables at the top of the script with your actual values. 4. **Run the Script:** ```bash python your_script_name.py ``` 5. **Test with a Client:** You'll need a client application to send requests to the MCP server. Here's a simple Python client example: ```python import socket import json MCP_HOST = 'localhost' MCP_PORT = 12345 def send_request(prompt, origin): """Sends a request to the MCP server.""" with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((MCP_HOST, MCP_PORT)) message = json.dumps({"prompt": prompt, "origin": origin}) s.sendall(message.encode('utf-8')) data = s.recv(1024) print(f"Received: {data.decode('utf-8')}") if __name__ == "__main__": prompt = "Write a short poem about the ocean." origin = "localhost" # Or "127.0.0.1" send_request(prompt, origin) ``` **Important Considerations:** * **Error Handling:** The error handling in the example is basic. You should implement more robust error handling, including logging and retries. * **Security:** The origin check is extremely basic. For production environments, you *must* implement proper authentication and authorization to prevent unauthorized access. Consider using TLS/SSL for secure communication. * **Scalability:** For high-volume traffic, consider using a more scalable MCP server architecture, such as a message queue (e.g., RabbitMQ, Kafka) or a load balancer. You might also need to scale your Bedrock usage. * **Bedrock Model Configuration:** The `invoke_bedrock()` function needs to be carefully configured based on the specific Bedrock model you're using. Refer to the Bedrock documentation for the model's input and output formats, available parameters, and best practices. * **Asynchronous Processing:** For better performance, consider using asynchronous programming (e.g., `asyncio`) to handle multiple requests concurrently. * **Rate Limiting:** Be aware of Bedrock's rate limits and implement appropriate rate limiting in your MCP server to avoid exceeding those limits. * **Data Validation:** Validate the data received from clients to prevent malicious input. * **Logging:** Implement comprehensive logging to track requests, responses, and errors. This example provides a starting point. You'll need to adapt it to your specific requirements and environment. Remember to prioritize security, error handling, and scalability as you develop your application.

Apple Mail Summary MCP

Enables AI agents to fetch emails from local Apple Mail accounts and mailboxes, and parse Google Scholar alert emails to extract paper titles and links.

Openfort MCP Server

Enables AI assistants to interact with Openfort's wallet infrastructure, allowing them to create projects, manage configurations, generate wallets and users, and query documentation through 42 integrated tools.

Context Engine

A task-aware context compression layer for Agent workflows, RAG pipelines, and AI Coding assistants, reducing noisy logs, retrieval chunks, and code context into high-signal LLM inputs via CLI, Python SDK, and MCP.

MCP Knowledge Base Server

Provides semantic search and data retrieval capabilities over a knowledge base with multiple tools including keyword search, category filtering, and ID-based lookup with in-memory caching.

DesignBot MCP

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

xserver-files-mcp

A local stdio MCP server for managing files on XServer via SFTP, enabling secure file operations, backups, and workspace management for XServer hosting.

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.

spotify-mcp-server

Enables natural language control of Spotify, including search, playback, and device management, with robust error handling and automatic token refresh.

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.

fortimanager-mcp

This MCP server provides tools to interact with FortiManager via JSON-RPC, but is deprecated and replaced by a more efficient Code Mode architecture.

automatised-pipeline

A Rust MCP server that indexes codebases into a property graph and provides tools for code intelligence, such as searching, context, impact analysis, and change detection.

TeslaMate MCP Server

Exposes TeslaMate HTTP APIs (health, logging, drive GPX) and a generic API request tool for interacting with a TeslaMate instance via MCP.

Scryfall MCP Server

Provides AI assistants with access to Magic: The Gathering card data via Scryfall API, enabling card search, image downloads, and database management.

pipedrive-mcp

MCP server for Pipedrive CRM providing 88 tools for full CRUD on deals, persons, organizations, activities, and more, with custom field resolution and safety guards.

viraill-mcp

Enables MCP clients to audit AI search visibility, generate intent-aligned social content, and assess Agentic Commerce Readiness with remediation files.

Ametller Origen

Enables shopping Ametller Origen online groceries through Claude, allowing catalog browsing, cart management, and order history access, with payment handled directly on the retailer's site.

FastMail MCP Server

An MCP server that integrates with FastMail's JMAP API to manage mailboxes, search for emails, and send messages. It enables users to interact with their FastMail account for tasks like reading email content and managing folders through natural language.

CommonGrants Grant Seeker

An MCP server that searches grant opportunities across multiple CommonGrants-compliant APIs from a single set of tools.

CSL MCP Server

A local MCP server for querying Chinese scientific literature from the CSL dataset, enabling paper search, detail retrieval, and dataset statistics via MCP clients.

TermPipe MCP

Provides AI assistants with direct terminal access to execute commands, manage files, and run persistent REPL sessions. It features automated installation scripts that educate AI assistants on its capabilities for seamless integration.