Discover Awesome MCP Servers

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.

linux-computer-use

MCP server enabling AI agents to control a real Linux browser with live view, human takeover, and safety guardrails.

playwright-mcp-server

Deploys a stateless remote MCP server on Cloudflare Workers without authentication, enabling tools to be used with Cloudflare AI Playground or local clients like Claude Desktop.

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.

RecargaPay MCP

Connects RecargaPay accounts to AI agents via Open Finance Brasil, enabling read-only queries about balances, statements, credit card bills, and investments in natural language.

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.

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.

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.

mechanic-mcp

Enables searching, fetching, and customizing Mechanic tasks and documentation for Shopify automation. Provides offline access to bundled task library and docs with tools for task code, docs content, and similar task suggestions.

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

Um servidor MCP para permitir que o LLM no Cursor acesse o Rust Analyzer, a documentação de Crate e os comandos Cargo.

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.

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.

scopa-mcp-server

An MCP server for playing the Italian card game Scopa, supporting 2-4 players, Redis-backed event logging, real-time synchronization, and an optional LLM opponent.

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.

Multi-Domain Booking MCP Server

Enables booking for movies, flights, trains, and buses with a 2-step confirmation flow and idempotency keys.

WuWa MCP Server

Enables querying detailed information about characters, echoes, and character profiles from the Wuthering Waves game, returning results in LLM-optimized Markdown format.

AskHumanToWork MCP Server

Enables AI agents to capture, manage, and retrieve todos with due dates and provenance, while automatically escalating reminders until tasks are completed.

ellmos-homebase-mcp

Enables local-first LLM orchestration with persistent memory, knowledge management, routing, swarm patterns, API probing, tests, automation planning, and plugin discovery via a stdio MCP server, using SQLite for offline storage.

CSMAR Web-API MCP

Enables MCP clients to search, browse, preview, and download CSMAR financial data using institutional IP authentication, no account or password required.

terminal-toolkit-mcp

Enables LLM clients to execute shell commands safely through the MCP protocol, with features like session management, safe mode, and process control.

x64dbg MCP server

Um servidor MCP para o 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-mysql-apifox

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

MCP with Langchain Sample Setup

Okay, here's a sample setup for an MCP (Modular Component Protocol) server and client, designed to be compatible with LangChain. This example focuses on a simple "summarization" task, but you can adapt it to other LangChain functionalities. **Important Considerations:** * **MCP (Modular Component Protocol):** MCP isn't a widely standardized protocol. This example uses a simplified, custom implementation based on JSON over HTTP for demonstration purposes. In a real-world scenario, you might consider more robust solutions like gRPC, Thrift, or even well-defined REST APIs. * **LangChain Integration:** The key is to use LangChain components (e.g., LLMs, chains, document loaders) *within* the MCP server to process requests. The client sends data, the server uses LangChain to process it, and the server returns the result. * **Error Handling:** This is a simplified example. Robust error handling (try-except blocks, logging, proper HTTP status codes) is crucial in a production environment. * **Security:** This example lacks security measures (authentication, authorization). Implement appropriate security based on your needs. * **Asynchronous Operations:** For more complex tasks, consider using asynchronous operations (e.g., `asyncio` in Python) to improve performance and prevent blocking. **Python Code (Example):** **1. MCP Server (using Flask):** ```python from flask import Flask, request, jsonify from langchain.llms import OpenAI from langchain.chains.summarize import load_summarize_chain from langchain.document_loaders import TextLoader # Or other loaders from langchain.text_splitter import CharacterTextSplitter import os # Set your OpenAI API key (or use environment variables) os.environ["OPENAI_API_KEY"] = "YOUR_OPENAI_API_KEY" # Replace with your actual key app = Flask(__name__) @app.route('/summarize', methods=['POST']) def summarize_text(): try: data = request.get_json() text = data.get('text') if not text: return jsonify({'error': 'Missing "text" parameter'}), 400 # LangChain components llm = OpenAI(temperature=0) # Adjust temperature as needed summarize_chain = load_summarize_chain(llm, chain_type="map_reduce") # or "stuff", "refine" # Prepare the document (using a dummy TextLoader for demonstration) # In a real scenario, you might load from a file, database, etc. # For large texts, split into chunks text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_text(text) # Create LangChain documents from the text chunks from langchain.docstore.document import Document docs = [Document(page_content=t) for t in texts] # Run the summarization chain summary = summarize_chain.run(docs) return jsonify({'summary': summary}) except Exception as e: print(f"Error: {e}") # Log the error return jsonify({'error': str(e)}), 500 # Return error with status code if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Make accessible on network ``` **2. MCP Client (using `requests`):** ```python import requests import json def summarize_with_mcp(text, server_url="http://localhost:5000/summarize"): """ Sends text to the MCP server for summarization. Args: text: The text to summarize. server_url: The URL of the MCP server's summarize endpoint. Returns: The summary from the server, or None if there was an error. """ try: payload = {'text': text} headers = {'Content-Type': 'application/json'} response = requests.post(server_url, data=json.dumps(payload), headers=headers) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() return data.get('summary') except requests.exceptions.RequestException as e: print(f"Error connecting to server: {e}") return None except json.JSONDecodeError as e: print(f"Error decoding JSON response: {e}") return None except Exception as e: print(f"An unexpected error occurred: {e}") return None if __name__ == '__main__': sample_text = """ This is a long piece of text that needs to be summarized. It contains important information about LangChain and MCP. LangChain is a powerful framework for building applications using large language models. MCP, in this context, is a simple protocol for communication between a client and a server. The server uses LangChain to process requests from the client. This example demonstrates a basic summarization task. More complex tasks can be implemented using different LangChain components and chains. Error handling and security are important considerations for production deployments. """ summary = summarize_with_mcp(sample_text) if summary: print("Summary:", summary) else: print("Failed to get summary.") ``` **Explanation:** * **Server (Flask):** * Uses Flask to create a simple HTTP server. * The `/summarize` endpoint receives POST requests with a JSON payload containing the `text` to summarize. * It initializes LangChain components: `OpenAI` (the LLM) and `load_summarize_chain` (the summarization chain). You'll need an OpenAI API key. * It loads the text into a LangChain `Document`. For larger texts, it splits the text into chunks using `CharacterTextSplitter`. * It runs the summarization chain and returns the summary in a JSON response. * Includes basic error handling. * **Client:** * Uses the `requests` library to send a POST request to the server's `/summarize` endpoint. * It packages the text to be summarized in a JSON payload. * It handles potential errors during the request (e.g., connection errors, bad responses). * It prints the summary received from the server. **How to Run:** 1. **Install Dependencies:** ```bash pip install flask langchain openai requests tiktoken ``` 2. **Set OpenAI API Key:** Replace `"YOUR_OPENAI_API_KEY"` in the server code with your actual OpenAI API key. Consider using environment variables for security. 3. **Run the Server:** ```bash python your_server_file.py # e.g., python mcp_server.py ``` 4. **Run the Client:** ```bash python your_client_file.py # e.g., python mcp_client.py ``` **Key Adaptations for Different LangChain Tasks:** * **Different Chains:** Instead of `load_summarize_chain`, use other LangChain chains (e.g., `LLMChain`, `ConversationalRetrievalChain`) based on the task you want to perform. * **Different LLMs:** Use other LLMs besides `OpenAI` (e.g., `HuggingFaceHub`, `Cohere`). You'll need to install the appropriate LangChain integration and configure the LLM. * **Data Loading:** Use different LangChain document loaders (e.g., `WebBaseLoader`, `CSVLoader`, `PDFMinerLoader`) to load data from various sources. * **Input/Output:** Adjust the input and output data formats in the server and client to match the requirements of your task. For example, you might send a question and receive an answer, or send a list of documents and receive a ranked list of relevant documents. * **Prompt Engineering:** Carefully design the prompts used in your LangChain chains to achieve the desired results. **Example in Portuguese (Translation of the Explanation):** Aqui está uma configuração de exemplo para um servidor e cliente MCP (Modular Component Protocol), projetada para ser compatível com LangChain. Este exemplo se concentra em uma tarefa simples de "resumo", mas você pode adaptá-lo para outras funcionalidades do LangChain. **Considerações Importantes:** * **MCP (Modular Component Protocol):** MCP não é um protocolo amplamente padronizado. Este exemplo usa uma implementação personalizada simplificada baseada em JSON sobre HTTP para fins de demonstração. Em um cenário do mundo real, você pode considerar soluções mais robustas como gRPC, Thrift ou até mesmo APIs REST bem definidas. * **Integração com LangChain:** A chave é usar componentes LangChain (por exemplo, LLMs, chains, carregadores de documentos) *dentro* do servidor MCP para processar solicitações. O cliente envia dados, o servidor usa LangChain para processá-los e o servidor retorna o resultado. * **Tratamento de Erros:** Este é um exemplo simplificado. O tratamento robusto de erros (blocos try-except, registro, códigos de status HTTP adequados) é crucial em um ambiente de produção. * **Segurança:** Este exemplo carece de medidas de segurança (autenticação, autorização). Implemente a segurança apropriada com base em suas necessidades. * **Operações Assíncronas:** Para tarefas mais complexas, considere usar operações assíncronas (por exemplo, `asyncio` em Python) para melhorar o desempenho e evitar bloqueios. **Código Python (Exemplo):** (O código Python permaneceria o mesmo, pois é código e não precisa ser traduzido. Apenas a explicação é traduzida.) **Explicação:** * **Servidor (Flask):** * Usa Flask para criar um servidor HTTP simples. * O endpoint `/summarize` recebe solicitações POST com um payload JSON contendo o `text` a ser resumido. * Ele inicializa os componentes LangChain: `OpenAI` (o LLM) e `load_summarize_chain` (a chain de resumo). Você precisará de uma chave de API OpenAI. * Ele carrega o texto em um `Document` LangChain. Para textos maiores, ele divide o texto em partes usando `CharacterTextSplitter`. * Ele executa a chain de resumo e retorna o resumo em uma resposta JSON. * Inclui tratamento de erros básico. * **Cliente:** * Usa a biblioteca `requests` para enviar uma solicitação POST para o endpoint `/summarize` do servidor. * Ele empacota o texto a ser resumido em um payload JSON. * Ele lida com possíveis erros durante a solicitação (por exemplo, erros de conexão, respostas ruins). * Ele imprime o resumo recebido do servidor. **Como Executar:** (As instruções de execução permanecem as mesmas, pois são comandos e não precisam ser traduzidas.) **Principais Adaptações para Diferentes Tarefas LangChain:** * **Chains Diferentes:** Em vez de `load_summarize_chain`, use outras chains LangChain (por exemplo, `LLMChain`, `ConversationalRetrievalChain`) com base na tarefa que você deseja executar. * **LLMs Diferentes:** Use outros LLMs além de `OpenAI` (por exemplo, `HuggingFaceHub`, `Cohere`). Você precisará instalar a integração LangChain apropriada e configurar o LLM. * **Carregamento de Dados:** Use diferentes carregadores de documentos LangChain (por exemplo, `WebBaseLoader`, `CSVLoader`, `PDFMinerLoader`) para carregar dados de várias fontes. * **Entrada/Saída:** Ajuste os formatos de dados de entrada e saída no servidor e no cliente para corresponder aos requisitos de sua tarefa. Por exemplo, você pode enviar uma pergunta e receber uma resposta, ou enviar uma lista de documentos e receber uma lista classificada de documentos relevantes. * **Engenharia de Prompt:** Projete cuidadosamente os prompts usados em suas chains LangChain para obter os resultados desejados. This provides a basic framework. Remember to adapt it to your specific use case and add proper error handling, security, and performance optimizations. 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.

steps-mcp

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