Discover Awesome MCP Servers

research-mcp

A citation-finding research assistant for scientists, exposed as an MCP server that extracts claims from draft paragraphs, searches multiple academic sources, scores paper quality, and explains recommendations.

Qobrix CRM MCP Server

A read-only MCP server providing 56 tools to query Qobrix real-estate CRM data, covering listings, leads, viewings, offers, contracts, analytics, and more, with RESO Data Dictionary alignment and caching support.

Cirvoy-Kiro MCP Integration

Enables seamless task synchronization between Kiro IDE and the Cirvoy project management platform. It provides tools to create, list, and update tasks directly within the IDE using the Model Context Protocol.

Seleniumboot MCP

Python MCP server for Selenium WebDriver — 84 tools for browser automation, element interactions, assertions, self-healing locators, and codegen for Java TestNG / JUnit 5 / Cucumber / pytest / C# NUnit / Playwright and CI pipelines (GitHub Actions / Jenkins / GitLab CI). No ChromeDriver setup needed.

ZoneMender

MCP server for AI agents to safely manage Cloudflare DNS, DMARC, SPF, BIMI, and Email Routing with dry-run-first and approval-based writes.

phren

A persistent memory server for AI agents that stores findings, tasks, and patterns in Markdown files within a git repository, enabling context injection across multiple AI tools.

comfyui-mcp-server-node

A lightweight MCP server that bridges AI agents with a local ComfyUI instance to generate and iteratively refine images, audio, and video through conversational tool calls.

StarUML MCP Server

Enables creating diagrams or generating code from diagrams in StarUML via prompts.

FGTS: Guia de Arrecadação

Enables consultation of FGTS (Brazilian severance guarantee fund) collection guides from official sources via a hosted, read-only MCP server. Supports natural language queries through any MCP client with pay-per-use credit.

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.

Amazon Business Integrations MCP Server

Provides AI-enabled access to Amazon Business API documentation, sample code, and troubleshooting resources. Enables developers to search and retrieve API documentation, generate integration code, and get guided solutions for common errors during the API integration process.

사주 MCP 대시보드

Korean traditional saju (four pillars) fortune analysis MCP server with a premium web GUI dashboard for local data persistence, 100-point scoring, and history management.

blender-MCP

Enables safe, repeatable preparation of game characters in Blender through high-level MCP tools for validation, import, normalization, action renaming, and GLB export, with dry-run by default and loopback-only security.

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.

iLoveVideoEditor MCP Server

Enables AI agents to render videos with iLoveVideoEditor by listing templates, filling in variables, submitting render jobs, polling status, and retrieving download URLs.

zoom-mcp

MCP server for Zoom's Users Admin REST API, providing 71 tools to manage users, groups, contact groups, and divisions for account creation and validation.

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.

x64dbg MCP server

Un servidor MCP para el depurador x64dbg.

Internship Scout & Quality of Life MCP Server

Integrates Eurostat quality-of-life metrics and real-time job searching to help users find international internships in high-ranking European cities. It enables ranking cities based on personalized criteria like safety or transport and retrieves structured internship listings via the Tavily API.

EditX

An MCP server for taking screenshots and editing images with annotations, shapes, and effects.

mcp-sphinx-docs

Converts Sphinx documentation (RST) to Markdown optimized for LLMs, enabling easy consumption of technical documentation by language models.

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.

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.

web-scrapper-mcp

A portable MCP server that scrapes SPA/JS-rendered webpages and extracts structured API endpoint data. It uses headless Chromium to render JavaScript and provides tools for scraping, endpoint extraction, screenshots, and database seeding.

mcp-mysql-apifox

MCP server for executing MySQL SQL, managing Apifox API documentation, and parsing/executing curl commands.

mcp-data-analysis-agent

A local-first MCP server that provides safe, governed read-only SQL access to SQLite and PostgreSQL, with validation, limits, task tracking, and report generation.

Crow

MCP server for read-only CrowdStrike Falcon visibility, enabling AI agents to list and retrieve detections, alerts, hosts, incidents, perform IOC lookups, and run LogScale queries.

Vora

First Voice AI MCP for AI Agents

DevTools MCP

Enables developers to explain error messages, validate and format JSON, generate regex patterns from descriptions, and summarize text via an LLM, all through MCP-connected clients.

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.