Discover Awesome MCP Servers

MCP MySQL Server

Enables interaction with MySQL databases (including AWS RDS and cloud instances) through natural language. Supports database connections, query execution, schema inspection, and comprehensive database management operations.

Cursor Rust Tools

Un servidor MCP para permitir que el LLM en Cursor acceda a Rust Analyzer, Crate Docs y comandos de Cargo.

MCP Prompt Optimizer

This MCP server provides research-backed prompt optimization tools and professional domain templates designed to improve AI performance through strategies like Tree of Thoughts and Medprompt. It enables users to analyze, auto-optimize, and refine prompts using advanced reasoning patterns and safety-critical alignment techniques.

zoho-mail-mcp

MCP server for Zoho Mail — read, search, and send email via Claude. Supports listing inbox, searching by keyword or sender, reading full message bodies, and sending HTML email.

Meraki Magic MCP

A Python-based MCP server that enables querying Cisco's Meraki Dashboard API to discover, monitor, and manage Meraki environments.

TypeScript MCP Server Boilerplate

A boilerplate project for quickly developing Model Context Protocol (MCP) servers using TypeScript SDK, with examples of tools (calculator, greeting) and resources (server info).

mysql-mcp

A lightweight MCP server providing safe, read-only access to MySQL databases. It enables users to query multiple MySQL instances securely while preventing write operations.

SuperCollider MCP Server

Model Context Protocol (MCP) server for SuperCollider integration with Claude Code and other MCP clients.

osc-bridge

OSC ↔ MIDI/SysEx bridge for 849 synths and DAWs — a MIDI MCP and OSC MCP.

X MCP Server

Enables users to interact with X (Twitter) through the X API. Supports posting tweets, retrieving user timelines, searching tweets, and replying to tweets with comprehensive error handling.

Vault MCP

Enables LLM agents to securely use credentials like passwords and API keys without exposing them in the context window, through encrypted storage and proxy-based injection.

opencode-lens

MCP server that enables inspecting, controlling, and safely automating live opencode TUI sessions.

GoHighLevel MCP Server

A Model Context Protocol (MCP) server that provides tools for managing GoHighLevel (GHL) conversations, tasks, and calendar appointments through AI assistants like Claude.

Genesis MCP Server

A template for deploying remote MCP servers on Cloudflare Workers without authentication. Provides a foundation for building custom MCP tools that can be accessed from Claude Desktop or the Cloudflare AI Playground.

Display & Video 360 API MCP Server

An MCP server that enables interaction with Google's Display & Video 360 advertising platform API, allowing management of digital advertising campaigns through natural language commands.

mcp-taginfo

Provides statistics on OpenStreetMap tags (keys and key=value pairs) via MCP tools, enabling querying of tag usage and metadata.

Sonic MCP Server

Enables AI agents to manage events, venues, songs, and users via the Sonic API, with integrated Spotify and Google Maps search.

database

Database MCP server for MySQL, MariaDB, PostgreSQL & SQLite

Apple Notes MCP

Comprehensive Apple Notes MCP server for local macOS note management.

Markdown MCP Server

An MCP (Model Context Protocol) server for efficiently managing Markdown documents in Cursor AI IDE, supporting CRUD operations, search, and metadata management.

MCP with Langchain Sample Setup

Okay, here's a sample setup for a minimal MCP (Message Passing Communication) server and client in Python, designed to be compatible with LangChain. This example focuses on the core communication and doesn't include LangChain-specific logic within the server/client themselves. The idea is that you'd use this communication channel to send data to and from a LangChain agent or chain running on a separate server. **Important Considerations:** * **Simplicity:** This is a basic example. For production, you'd need to add error handling, security (authentication, encryption), more robust message formatting, and potentially asynchronous communication. * **LangChain Integration:** The LangChain part happens *outside* of this code. You'd use the client to send prompts to a LangChain agent running on the server and receive the agent's responses. * **Message Format:** I'm using JSON for simplicity. You could use other formats like Protocol Buffers for better performance and schema validation. * **Threading/Asyncio:** This example uses basic threading. For higher concurrency, consider using `asyncio`. **Code:** ```python import socket import threading import json # Server class MCPServer: def __init__(self, host='localhost', port=12345): self.host = host self.port = port self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Allow reuse of address self.clients = [] # Keep track of connected clients def start(self): self.server_socket.bind((self.host, self.port)) self.server_socket.listen(5) # Listen for up to 5 incoming connections print(f"Server listening on {self.host}:{self.port}") while True: client_socket, addr = self.server_socket.accept() print(f"Accepted connection from {addr}") self.clients.append(client_socket) client_thread = threading.Thread(target=self.handle_client, args=(client_socket,)) client_thread.start() def handle_client(self, client_socket): try: while True: data = client_socket.recv(4096) # Receive up to 4096 bytes if not data: break # Client disconnected try: message = json.loads(data.decode('utf-8')) print(f"Received message: {message}") # **LangChain Integration Point:** # Here, you would pass the 'message' to your LangChain agent/chain # and get a response. For example: # response = my_langchain_agent.run(message['prompt']) # response_message = {'response': response} # self.send_message(client_socket, response_message) # For this example, just echo the message back: self.send_message(client_socket, {"response": f"Server received: {message}"}) except json.JSONDecodeError: print("Received invalid JSON data.") self.send_message(client_socket, {"error": "Invalid JSON"}) except Exception as e: print(f"Error handling client: {e}") finally: print(f"Closing connection with {client_socket.getpeername()}") self.clients.remove(client_socket) client_socket.close() def send_message(self, client_socket, message): try: message_json = json.dumps(message) client_socket.sendall(message_json.encode('utf-8')) except Exception as e: print(f"Error sending message: {e}") def stop(self): for client in self.clients: client.close() self.server_socket.close() print("Server stopped.") # Client class MCPClient: def __init__(self, host='localhost', port=12345): self.host = host self.port = port self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) def connect(self): try: self.client_socket.connect((self.host, self.port)) print(f"Connected to server at {self.host}:{self.port}") return True except socket.error as e: print(f"Connection error: {e}") return False def send_message(self, message): try: message_json = json.dumps(message) self.client_socket.sendall(message_json.encode('utf-8')) data = self.client_socket.recv(4096) if data: response = json.loads(data.decode('utf-8')) return response else: return None except Exception as e: print(f"Error sending/receiving message: {e}") return None def close(self): self.client_socket.close() print("Connection closed.") # Example Usage (in separate files or at the end of the same file) if __name__ == "__main__": # Server Example server = MCPServer() server_thread = threading.Thread(target=server.start) server_thread.daemon = True # Allow the main thread to exit even if the server thread is running server_thread.start() # Client Example import time time.sleep(1) # Give the server a moment to start client = MCPClient() if client.connect(): message = {"prompt": "What is the capital of France?"} response = client.send_message(message) if response: print(f"Received response: {response}") else: print("No response received.") client.close() server.stop() # Stop the server after the client is done. ``` **Explanation:** 1. **`MCPServer` Class:** * `__init__`: Initializes the server socket, host, and port. `setsockopt` allows reusing the address, which is helpful for quick restarts. * `start`: Binds the socket, listens for connections, and spawns a new thread for each client that connects. * `handle_client`: This is the core of the server. It receives data from the client, decodes it as JSON, and then (crucially) this is where you would integrate with your LangChain agent or chain. The example code just echoes the message back. It also handles JSON decoding errors. * `send_message`: Encodes a message as JSON and sends it to the client. * `stop`: Closes all client connections and the server socket. 2. **`MCPClient` Class:** * `__init__`: Initializes the client socket, host, and port. * `connect`: Connects to the server. * `send_message`: Encodes a message as JSON, sends it to the server, receives the response, decodes the response as JSON, and returns it. * `close`: Closes the client socket. 3. **Example Usage:** * Creates a server instance and starts it in a separate thread (using `threading.Thread`). The `daemon = True` makes the server thread exit when the main thread exits. * Creates a client instance, connects to the server, sends a message (a prompt), receives the response, and prints the response. * Closes the client connection. * Stops the server. **How to Run:** 1. Save the code as a Python file (e.g., `mcp_example.py`). 2. Run the file from your terminal: `python mcp_example.py` You should see output from both the server and the client. The client will send a message, and the server will echo it back. **LangChain Integration (Conceptual):** The key part is in the `handle_client` method of the `MCPServer` class. Instead of just echoing the message, you would do something like this: ```python # Inside the handle_client method: try: message = json.loads(data.decode('utf-8')) print(f"Received message: {message}") # **LangChain Integration:** from langchain.llms import OpenAI # Or your preferred LLM from langchain.chains import LLMChain from langchain.prompts import PromptTemplate # Example using OpenAI and a simple prompt llm = OpenAI(temperature=0.7, openai_api_key="YOUR_OPENAI_API_KEY") # Replace with your API key prompt_template = PromptTemplate.from_template("{prompt}") chain = LLMChain(llm=llm, prompt=prompt_template) response = chain.run(message['prompt']) # Run the LangChain chain response_message = {'response': response} self.send_message(client_socket, response_message) except json.JSONDecodeError: print("Received invalid JSON data.") self.send_message(client_socket, {"error": "Invalid JSON"}) ``` **Important Notes for LangChain:** * **Install LangChain:** `pip install langchain openai` (or other necessary packages). * **API Keys:** You'll need to set up your API keys for the LLMs you're using (e.g., OpenAI). Don't hardcode them directly in the code; use environment variables or a configuration file. * **Error Handling:** Add more robust error handling around the LangChain calls. * **Prompt Engineering:** The quality of your prompts will greatly affect the results. * **Asynchronous Communication (Advanced):** For high-volume scenarios, consider using `asyncio` for both the server and the client to handle multiple requests concurrently. This will significantly improve performance. **Spanish Translation of Key Concepts:** * **Server:** Servidor * **Client:** Cliente * **Message:** Mensaje * **Prompt:** Indicación, Instrucción * **Response:** Respuesta * **Socket:** Zócalo (although "socket" is often used directly in technical contexts) * **Connection:** Conexión * **Thread:** Hilo * **JSON:** JSON (pronounced the same) * **LangChain Agent:** Agente de LangChain * **LangChain Chain:** Cadena de LangChain * **API Key:** Clave API This comprehensive example should give you a solid foundation for building an MCP server and client that can communicate with a LangChain agent. Remember to adapt the code to your specific needs and add the necessary error handling and security measures.

Hurricane Tracker MCP Server

Provides real-time hurricane tracking, 5-day forecast cones, location-based alerts, and historical storm data from NOAA/NHC through MCP tools for AI assistants.

remote-mcp-server-authless

Deploy a remote MCP server on Cloudflare Workers without authentication, supporting custom tools and connections to AI Playground or Claude Desktop.

Spotinst MCP Server

An MCP server for the Spot.io API that enables management of AWS and Azure Ocean clusters across multiple accounts. It provides tools for cluster inventory, node management, cost analysis, and scaling operations through natural language.

Plasmate

Agent-native headless browser for AI agents. Converts web pages to a Semantic Object Model (SOM) instead of raw HTML — 17x average token reduction across real-world sites (up to 117x on complex pages). Native MCP server with fetch_page, extract_text, extract_links, and full browser automation. No API key required.

Vora

First Voice AI MCP for AI Agents

MCP Tool Server

A Model Context Protocol server that advertises tools with JSON schemas and executes tool calls safely, enabling AI agents to perform actions on real systems.

random-number-server

An MCP server that generates random numbers by using national weather data as entropy seeds. It provides a unique way to generate random values through weather API integration within the Model Context Protocol.

MegaMem

Syncs Obsidian notes into a temporal knowledge graph and exposes 23 MCP tools for AI assistants to read, search, and write to your vault, enabling persistent memory across conversations.