Discover Awesome MCP Servers

Expense_Tracker_MCP

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

Whoop MCP Server

Connects Whoop health data to Claude via an MCP server, enabling retrieval of recovery, sleep, strain, and workout metrics through natural language tools.

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.

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.

Accounting MCP Server

Enables personal financial management through AI assistants by providing tools to add transactions, check balances, list transaction history, and generate monthly summaries. Supports natural language interaction for tracking income and expenses with categorization.

au-weather-mcp

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

Prompt Bookmarks

Enables users to organize, search, and manage a shared library of prompts across AI tools via the Model Context Protocol. It supports hierarchical folder organization, tagging, and template variable substitution for dynamic prompt generation.

Android Puppeteer

Enables AI agents to interact with Android devices through visual UI element detection and automated interactions. Provides comprehensive Android automation capabilities including touch gestures, text input, screenshots, and video recording via uiautomator2.

FastMCP Demo Server

A production-ready MCP server that provides hackathon resources and reusable starter prompts. Built with FastMCP framework and includes comprehensive deployment options for development and production environments.

mcp-units

MCP server for converting cooking measurements (volume, weight, temperature) between common units like ml, cup, g, oz, and Celsius/Fahrenheit.

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.

PostgreSQL MCP Server

Enables LLMs to interact deeply with PostgreSQL databases—query data, manage schema, analyze performance, and administer the database.

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.

SEOforGPT MCP Server

Enables AI-driven brand visibility monitoring and SEO project management via the SEOforGPT API. Users can execute brand visibility checks, list projects, and retrieve detailed visibility reports through natural language interactions.

hive-exp

An MCP server enabling AI agents to record, query, and share structured problem-solving experiences with human review and confidence decay.

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.

gemini-image-mcp

Enables Claude Code to generate and edit images using Google's Gemini and Imagen models on Vertex AI, with support for multiple models, aspect ratios, and image fusion.

kef-mcp

MCP server for controlling KEF wireless speakers (LSX II, LS50 Wireless II, LS60) and playing Spotify on them via local network and Spotify Web API.

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).

chrome-agent-mcp

Enables AI agents to fully control Google Chrome: navigate, click, fill forms, inspect DevTools, and manage tabs with parallel execution and session isolation.

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.

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.

GitHub MCP Server

Enables users to interact with GitHub via natural language requests, executing API calls and returning structured responses.

NannyKeeper MCP Server

Enables AI agents to calculate US household employer (nanny) taxes for all 50 states plus DC, including Social Security, Medicare, FUTA, and state unemployment, through natural language.

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!