Discover Awesome MCP Servers

findata-mcp

A Financial Data Quality and AI Inference Evaluation MCP server that provides tools for auditing, bias detection, model evaluation, outlier scoring, A/B testing, and KPI reporting.

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.

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.

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.

steps-mcp

Task planning and execution MCP server with durable SQLite storage and a browser UI for reviewing plans and following progress.

oaid-mcp

Enables AI agents to securely use Open Agent ID credentials for signing requests, looking up agent data, and exchanging encrypted messages. It performs all cryptographic operations within the server process to ensure private keys are never exposed to the AI agent.

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.

tokencast

Pre-execution cost estimation for LLM agent workflows, providing cost estimates before running tasks and improving accuracy over time through calibration.

wheelfor-mcp

Create, spin, and manage shareable decision wheels on wheelfor.com. Supports creating wheels from any list of options, spinning for a random result, and getting a permanent shareable URL — no account required.

TickTick MCP

A remote MCP server that enables Claude to create and manage TickTick to-dos using the TickTick Open API. It supports nine tools for projects, tasks, and sections, and works across all Claude platforms (web, mobile, desktop, Cowork).

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.

atom-mcp-server

Global price benchmarking for AI inference across 2,600+ SKUs from 47 vendors. Query live pricing, market indexes, and model specs via 8 tools. Free tier available.

au-weather-mcp

Provides access to Australian weather data from the Bureau of Meteorology, enabling location search, forecasts, and current observations.

framefetch

Agent-first video-data API + MCP across 6 platforms (YouTube/Shorts, TikTok, Reddit, Instagram, Pinterest): metadata, insights, Whisper transcript, and parametric frames. Pay-per-call via x402 (USDC) or Stripe.

Brickognize MCP Server

Identifies LEGO parts, sets, and minifigures from local image files using the Brickognize API. It provides specialized tools for specific item recognition and integrates LEGO identification capabilities into MCP-enabled environments.

StarUML MCP Server

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

Copper CRM MCP Server

Enables AI agents to read and manage Copper CRM data, including searching people, companies, and opportunities, listing pipelines, and logging activities or creating tasks.

crowd-test-mcp

▎ Enables AI assistants to unleash a crowd of role-played virtual users — impatient shoppers, seniors, keyboard-only users, privacy hawks, chaos monkeys — on a website. Each persona browses in a real Chromium browser, files UX/QA findings in character, and the site receives a damage report with an S–F survival grade. Accusations can be cross-examined by up to three independent verification engines

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.

MCP Docker Sandbox Interpreter

A secure Docker-based environment that allows AI assistants to safely execute code without direct access to the host system by running all code within isolated containers.

Expense_Tracker_MCP

An AI-powered expense management server that enables adding, searching, and analyzing expenses using natural language through the Model Context Protocol.

Anonymix MCP

Provides local anonymization of Czech legal documents by replacing sensitive entities with pseudonyms to ensure privacy during LLM interactions. It allows users to safely process documents like contracts and judgments by keeping original data offline and facilitating local deanonymization.

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.

icloud-mcp

MCP server for iCloud integration, providing tools for managing calendars, contacts, and email.

WhatsApp MCP

Send WhatsApp messages from your own personal number via AI assistant, with confirm-before-send and ability to read and summarize recent chats.

Cursor Rust Tools

CursorのLLMがRust Analyzer、Crate Docs、CargoコマンドにアクセスできるようにするMCPサーバー。