Discover Awesome MCP Servers

hypernatt-terminal

BTC Decision Terminal for AI Agents — live vault-backed Hyperliquid signals, on-chain proof, cross-chain swap. MCP server hosted at https://hypernatt.com/mcp/protocol. 11 tools. Verify in real time.

MCP Injection Guard

Blocks indirect prompt injection by tracking data provenance, not text patterns. Enables safe agent interaction with untrusted content.

repo-ctx

Provides a unified context layer for LLMs by storing and retrieving repo-specific and cross-repo patterns via MCP tools, enabling instant context without re-exploring.

MP Mato Grosso (Procedimentos)

Enables querying extrajudicial investigative procedures from the Ministério Público de Mato Grosso for individuals or companies via CPF/CNPJ. It is a read-only, hosted MCP server with prepaid credits.

langfuse-mcp-python

A Model Context Protocol (MCP) server for comprehensive monitoring and observability of systems using Langfuse.

yuelinghuashu/story-cli

Git-native Markdown content management CLI with a built-in MCP server. Lets AI clients (Claude, Cursor) search, read, write, and govern story/paper/note repositories, auto-generate READMEs, validate configs, and export EPUB or SFT training data.

Pearch

Best people search engine that reduces the time spent on talent discovery

TradingView MCP Jackson

An MCP server that connects to TradingView Desktop via Chrome DevTools Protocol, enabling chart control, Pine Script development, and a morning brief workflow with AI-driven analysis.

Odoo MCP

Safety-first Model Context Protocol server for Odoo that enables AI assistants to safely inspect records, explain business data, prepare controlled changes, and rollback supported operations.

bd-crm-analytics

A read-only MCP server that exposes BD Leads CRM analytics (win rate, conversion funnel, connects economics, sales velocity, forecast, and lead lookup) to MCP clients like Cursor and Claude Desktop.

pl-holidays-mcp

Enables Polish public holiday lookups and business-day arithmetic (e.g., adding business days, counting business days) using the Nager.Date API, defaulting to Poland but supporting 110+ countries.

sumo-mcp

Enables searching Sumo Logic logs using the search_logs tool, with support for query parameters such as time range and maximum results.

TodoMCP

A local Model Context Protocol server that helps Codex turn requests into atomic tasks, manage plans, and rigorously verify completions without using any model API.

Agoragentic

Agent-to-agent marketplace where AI agents discover, invoke, and pay for services from other agents using USDC on Base L2. 72+ services, free tools, x402 micropayments.

mcp-for-apple-mail

MCP server that encapsulates Apple Mail on macOS via AppleScript, enabling invoice PDF search, attachment saving, and message flagging through natural language.

Continuum

Automatically extracts architectural decisions, patterns, and insights from Git commits to build a local, structured project memory. It exposes this living context to AI tools via MCP, allowing them to understand the historical reasoning and evolution behind your codebase.

telebotstudio-mcp

Enables AI assistants to search and retrieve official TeleBot Studio documentation via BM25, eliminating hallucinations by grounding responses in verified markdown files.

GTAV-CLAUDE-MCP

Enables Claude to see and act in Grand Theft Auto V, spawning vehicles, changing weather/time, calling game natives, and reading/writing memory, with an in-game chat panel for interacting with Claude while playing.

Atlassian MCP Server

Proporciona integración con los productos de Atlassian a través del Protocolo de Contexto de Modelo, permitiendo a los usuarios interactuar con tickets de JIRA y páginas de Confluence.

FastAPI Knowledge Base MCP Server

Provides RAG-based FastAPI documentation retrieval and project introspection tools via MCP, enabling LLMs to query reference docs, symbols, and project OpenAPI specs.

yes_chef_mcp

Enables AI assistants to search recipes, compose nutritionally balanced meals, optimize weekly meal plans based on macro targets for family members, and generate consolidated grocery lists from a personal recipe database.

MCP Apple Notes

Enables semantic search, connection discovery, and grounded synthesis across your Apple Notes using on-device embeddings and optional LLM synthesis, with direct SQLite access for fast indexing.

currency-converter

Converts between fiat and crypto currencies using ECB and CoinGecko rates, with pay-per-call via x402 micropayments.

MCP AI Developer Agent

An AI-powered developer assistant MCP server that provides filesystem tools (list_files, read_file, search_files, write_file) to help AI agents inspect, analyze, and modify real codebases via the Model Context Protocol.

Aareguru MCP Server

Provides Swiss Aare river swimming data including water temperature, flow rates, safety assessments, and forecasts. Enables AI assistants to answer questions about current conditions, compare cities, and provide safety recommendations based on official BAFU thresholds.

mcp-openrouteservice

Provides routing, distance/duration matrix, isochrones, snap to road, elevation, and geocoding tools from Openrouteservice for AI agents via MCP.

Cursor Sound MCP

Provides audio feedback by playing sound effects when Cursor AI completes code generation, creating a more interactive coding experience.

Add API key to .env file

Okay, here's a basic implementation of a simplified MCP (Master-Client-Process) system in Python, including a client and multiple servers. This is a conceptual example and lacks robust error handling, security, and advanced features. It's designed to illustrate the core principles. **Important Considerations:** * **Security:** This code is for demonstration purposes only. Do *not* use it in a production environment without adding proper security measures (authentication, encryption, etc.). * **Error Handling:** The error handling is minimal. A real-world system would need much more robust error handling. * **Scalability:** This is a very basic implementation and won't scale well to a large number of clients or servers. Consider using more advanced technologies like message queues (e.g., RabbitMQ, Kafka) for scalability. * **Threading/Asynchronous:** This example uses basic threading. For more efficient handling of multiple clients, consider using asynchronous programming (e.g., `asyncio`). **Code:** **1. Server (mcp_server.py):** ```python import socket import threading import time SERVER_HOST = '127.0.0.1' # Loopback address SERVER_PORT = 12345 # Choose a port MAX_CONNECTIONS = 5 def handle_client(client_socket, client_address): """Handles communication with a single client.""" print(f"Connection from {client_address}") try: while True: data = client_socket.recv(1024).decode('utf-8') if not data: break # Client disconnected print(f"Received from {client_address}: {data}") # Process the data (very simple example) response = f"Server received: {data.upper()}" client_socket.send(response.encode('utf-8')) except Exception as e: print(f"Error handling client {client_address}: {e}") finally: print(f"Connection closed with {client_address}") client_socket.close() def start_server(): """Starts the server and listens for incoming connections.""" server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((SERVER_HOST, SERVER_PORT)) server_socket.listen(MAX_CONNECTIONS) print(f"Server listening on {SERVER_HOST}:{SERVER_PORT}") try: while True: client_socket, client_address = server_socket.accept() client_thread = threading.Thread(target=handle_client, args=(client_socket, client_address)) client_thread.start() except KeyboardInterrupt: print("Server shutting down...") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **2. Client (mcp_client.py):** ```python import socket SERVER_HOST = '127.0.0.1' SERVER_PORT = 12345 def run_client(): """Connects to the server and sends/receives data.""" client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: client_socket.connect((SERVER_HOST, SERVER_PORT)) print(f"Connected to server at {SERVER_HOST}:{SERVER_PORT}") while True: message = input("Enter message to send (or 'exit'): ") if message.lower() == 'exit': break client_socket.send(message.encode('utf-8')) response = client_socket.recv(1024).decode('utf-8') print(f"Received from server: {response}") except Exception as e: print(f"Error: {e}") finally: print("Closing connection.") client_socket.close() if __name__ == "__main__": run_client() ``` **How to Run:** 1. **Save the code:** Save the server code as `mcp_server.py` and the client code as `mcp_client.py`. 2. **Start the server:** Open a terminal or command prompt and run `python mcp_server.py`. The server will start listening for connections. 3. **Start the client(s):** Open one or more other terminals/command prompts and run `python mcp_client.py` in each. Each client will connect to the server. 4. **Interact:** In each client terminal, type a message and press Enter. The message will be sent to the server, processed (in this simple example, converted to uppercase), and the response will be displayed in the client terminal. 5. **Exit:** Type `exit` in a client terminal to disconnect that client. Press Ctrl+C in the server terminal to shut down the server. **Explanation:** * **Server (mcp_server.py):** * Creates a socket and binds it to a specific IP address and port. * Listens for incoming connections using `server_socket.listen()`. * When a client connects (`server_socket.accept()`), it creates a new thread to handle the client's communication. This allows the server to handle multiple clients concurrently. * The `handle_client()` function receives data from the client, processes it (in this example, it just converts the message to uppercase), and sends a response back to the client. * The server continues to listen for new connections until it's interrupted (e.g., by pressing Ctrl+C). * **Client (mcp_client.py):** * Creates a socket and connects to the server's IP address and port. * Prompts the user to enter a message. * Sends the message to the server using `client_socket.send()`. * Receives the response from the server using `client_socket.recv()`. * Prints the response to the console. * The client continues to send and receive messages until the user enters "exit". **Key Concepts:** * **Sockets:** Sockets are the fundamental building blocks for network communication. They provide an endpoint for sending and receiving data. * **TCP (SOCK_STREAM):** TCP is a connection-oriented protocol that provides reliable, ordered delivery of data. It's suitable for applications that require guaranteed delivery, such as file transfer and web browsing. * **Threading:** Threading allows the server to handle multiple clients concurrently. Each client connection is handled in a separate thread. * **Encoding/Decoding:** Data is sent over the network as bytes. The `encode()` and `decode()` methods are used to convert strings to bytes and vice versa. UTF-8 is a common encoding that supports a wide range of characters. **Improvements and Extensions:** * **Error Handling:** Add more comprehensive error handling to catch exceptions and handle them gracefully. * **Security:** Implement authentication and encryption to protect the data being transmitted. Consider using TLS/SSL. * **Message Format:** Define a more structured message format (e.g., JSON, Protocol Buffers) to allow for more complex data to be exchanged. * **Asynchronous Programming:** Use `asyncio` for more efficient handling of multiple clients, especially if the server needs to handle a large number of concurrent connections. * **Master/Worker Pattern:** Implement a true master/worker pattern where the master server distributes tasks to worker servers. * **Message Queues:** Use a message queue (e.g., RabbitMQ, Kafka) to decouple the client and server and improve scalability and reliability. * **Configuration:** Use a configuration file to store server settings (e.g., IP address, port). * **Logging:** Implement logging to record server events and errors. This provides a basic foundation for understanding how an MCP system can be implemented in Python. Remember to adapt and extend this code to meet the specific requirements of your application.

xtai-mcp-data-analysis

An MCP server for data analysis and visualization supporting CSV and Excel files. It enables users to generate statistical summaries and create multi-dimensional charts like heatmaps and bar plots through natural language.

sushimcp

sushimcp