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

x64dbg デバッガー用の MCP サーバー

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 an MCP (presumably meaning "Message Passing Communication" or similar) server and client, designed to be compatible with LangChain. This example focuses on a simple request-response pattern using Python and a basic socket implementation. It prioritizes clarity and demonstrates the core concepts. You'll likely need to adapt it based on your specific MCP protocol and LangChain use case. **Important Considerations:** * **Error Handling:** This is a simplified example. Robust error handling (try-except blocks, connection timeouts, etc.) is crucial for production environments. * **Security:** Plain sockets are inherently insecure. For sensitive data, use TLS/SSL (e.g., `ssl.wrap_socket`). * **Serialization:** This example uses simple string encoding. For complex data structures, consider using `json`, `pickle`, or `protobuf` for serialization/deserialization. Choose a method that's efficient and secure. * **Asynchronous Communication:** For high-performance applications, consider using asynchronous libraries like `asyncio` instead of blocking sockets. * **LangChain Integration:** The LangChain integration is conceptual. You'll need to adapt the `process_request` function to interact with your LangChain components (e.g., chains, agents, memory). * **MCP Protocol Definition:** Clearly define your MCP protocol (message format, commands, error codes) for reliable communication. **Python Code:** ```python import socket import threading import json # For serialization (optional) # --- Server --- class MCPServer: def __init__(self, host='localhost', port=12345): self.host = host self.port = port self.server_socket = None self.running = False def start(self): self.server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 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}") self.running = True while self.running: try: client_socket, addr = self.server_socket.accept() print(f"Accepted connection from {addr}") client_thread = threading.Thread(target=self.handle_client, args=(client_socket,)) client_thread.start() except OSError: # Socket was closed (e.g., during shutdown) break def handle_client(self, client_socket): try: while True: data = client_socket.recv(1024).decode('utf-8') # Receive up to 1024 bytes if not data: break # Client disconnected print(f"Received: {data}") response = self.process_request(data) # Process the request (LangChain integration here) client_socket.sendall(response.encode('utf-8')) # Send the response except Exception as e: print(f"Error handling client: {e}") finally: client_socket.close() print("Connection closed.") def process_request(self, request): """ This is where you integrate with LangChain. Example: """ # Example: Assume the request is a question for a LangChain chain. # Replace this with your actual LangChain setup. try: # Assuming request is a JSON string request_data = json.loads(request) question = request_data.get("question") if question: # **LangChain Integration:** # Replace this with your actual LangChain chain execution. # result = your_langchain_chain.run(question) result = f"LangChain processed: {question}" # Placeholder response_data = {"answer": result} response = json.dumps(response_data) else: response = "Error: No 'question' field in request." except json.JSONDecodeError: response = "Error: Invalid JSON format." except Exception as e: response = f"Error processing request: {e}" return response def stop(self): self.running = False if self.server_socket: 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 = None def connect(self): self.client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) try: self.client_socket.connect((self.host, self.port)) print(f"Connected to {self.host}:{self.port}") except ConnectionRefusedError: print("Connection refused. Is the server running?") return False return True def send_message(self, message): try: self.client_socket.sendall(message.encode('utf-8')) data = self.client_socket.recv(1024).decode('utf-8') print(f"Received: {data}") return data except Exception as e: print(f"Error sending/receiving data: {e}") return None def close(self): if self.client_socket: self.client_socket.close() print("Connection closed.") # --- Example Usage --- if __name__ == "__main__": # Start the server in a separate thread 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() # Give the server a moment to start import time time.sleep(0.5) # Create a client and connect client = MCPClient() if client.connect(): # Send a message message = json.dumps({"question": "What is the capital of France?"}) response = client.send_message(message) if response: print(f"Server response: {response}") # Close the connection client.close() # Stop the server (after a delay) time.sleep(2) server.stop() ``` **Explanation:** 1. **`MCPServer` Class:** * `__init__`: Initializes the server with a host and port. * `start`: Creates a socket, binds it to the address, and listens for incoming connections. It then enters a loop, accepting connections and spawning a new thread for each client. * `handle_client`: Handles communication with a single client. It receives data, calls `process_request` to handle the request (and integrate with LangChain), and sends the response back to the client. * `process_request`: **This is the key part for LangChain integration.** It receives the request data, parses it (in this example, assuming JSON), and then uses LangChain to process the request. The result from LangChain is then formatted into a response and returned. **You'll need to replace the placeholder code with your actual LangChain chain/agent execution.** * `stop`: Stops the server by closing the socket. 2. **`MCPClient` Class:** * `__init__`: Initializes the client with a host and port. * `connect`: Creates a socket and connects to the server. * `send_message`: Sends a message to the server and receives the response. * `close`: Closes the connection. 3. **Example Usage (`if __name__ == "__main__":`)** * Starts the server in a separate thread. This is important because the `server.start()` method is blocking (it waits for connections). * Creates a client, connects to the server, sends a message, receives the response, and closes the connection. * Stops the server after a short delay. **How to Adapt for LangChain:** 1. **Install LangChain:** `pip install langchain` 2. **Import LangChain Modules:** Import the necessary LangChain modules in your `process_request` function (e.g., `from langchain.chains import LLMChain`, `from langchain.llms import OpenAI`). 3. **Initialize LangChain Components:** Initialize your LangChain models, chains, agents, and memory in the `process_request` function (or, ideally, initialize them once when the server starts and pass them to `process_request`). 4. **Replace Placeholder Code:** Replace the placeholder code in the `process_request` function with your actual LangChain chain/agent execution. For example: ```python # Example using a LangChain LLMChain from langchain.chains import LLMChain from langchain.llms import OpenAI from langchain.prompts import PromptTemplate def process_request(self, request): try: request_data = json.loads(request) question = request_data.get("question") if question: # **LangChain Integration:** llm = OpenAI(temperature=0.7) # Replace with your LLM prompt = PromptTemplate( input_variables=["question"], template="Answer the following question: {question}" ) chain = LLMChain(llm=llm, prompt=prompt) result = chain.run(question) response_data = {"answer": result} response = json.dumps(response_data) else: response = "Error: No 'question' field in request." except json.JSONDecodeError: response = "Error: Invalid JSON format." except Exception as e: response = f"Error processing request: {e}" return response ``` **To run this example:** 1. Save the code as a Python file (e.g., `mcp_example.py`). 2. Run the file from your terminal: `python mcp_example.py` This will start the server and client in the same process. The client will send a message to the server, and the server will respond. Remember to adapt the `process_request` function to your specific LangChain use case. **Japanese Translation of Key Concepts:** * **MCP (Message Passing Communication):** メッセージパッシング通信 (Messēji Passhingu Tsūshin) * **Server:** サーバー (Sābā) * **Client:** クライアント (Kurainto) * **Socket:** ソケット (Soketto) * **Connection:** 接続 (Setsuzoku) * **Request:** リクエスト (Rikuesuto) / 要求 (Yōkyū) * **Response:** レスポンス (Resuponsu) / 応答 (Ōtō) * **LangChain:** LangChain (ラングチェイン) (Usually kept in English) * **Thread:** スレッド (Sureddo) * **Serialization:** シリアライズ (Shiriaraizu) / 直列化 (Chokuretsuka) * **Deserialization:** デシリアライズ (Deshiriaraizu) / 逆直列化 (Gyaku Chokuretsuka) * **Error Handling:** エラー処理 (Erā Shori) * **Asynchronous:** 非同期 (Hidoōki) This comprehensive example should give you a solid foundation for building your MCP server and client with LangChain integration. Remember to prioritize error handling, security, and a well-defined MCP protocol for a robust and reliable system. Good luck!

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.