Discover Awesome MCP Servers

API Wrapper MCP Server

Okay, I understand you want to create an MCP (Modifiable Central Point) server that can handle requests for *any* API. This is a broad concept, so let's break down the challenges and outline a possible approach. **Understanding the Goal** The core idea is to build a flexible server that acts as a central point for accessing various APIs. This server should: * **Abstract API Complexity:** Hide the specific details of each API from the clients. * **Provide a Unified Interface:** Offer a consistent way to interact with different APIs. * **Enable Modification/Adaptation:** Allow you to easily change how the server interacts with the underlying APIs (e.g., change API keys, modify request parameters, transform responses). * **Potentially Add Features:** Implement features like caching, rate limiting, authentication, and authorization. **Challenges** * **API Diversity:** APIs have different authentication methods, request formats, response structures, error handling, and rate limits. * **Configuration Complexity:** Managing the configuration for each API can become complex. * **Security:** Protecting API keys and sensitive data is crucial. * **Scalability:** The server needs to handle a large number of requests efficiently. * **Maintainability:** The code needs to be well-structured and easy to maintain as APIs evolve. **Possible Architecture and Implementation** Here's a high-level architecture and implementation outline using Python and Flask (or FastAPI) as an example. You can adapt this to other languages and frameworks. 1. **Framework Selection:** * **Python (Flask or FastAPI):** Good choices for rapid development, flexibility, and a large ecosystem of libraries. FastAPI is generally preferred for its performance and automatic data validation. * **Node.js (Express.js):** Another popular option, especially if you're comfortable with JavaScript. * **Java (Spring Boot):** A robust choice for enterprise-level applications. 2. **Core Components:** * **API Router/Dispatcher:** This component receives incoming requests and routes them to the appropriate API handler based on the requested path or other criteria. * **API Handler Modules:** Each API you want to support will have its own handler module. This module is responsible for: * **Configuration:** Loading API-specific configuration (API keys, base URLs, etc.). * **Request Transformation:** Transforming the incoming request into the format expected by the target API. * **API Call:** Making the actual HTTP request to the target API. * **Response Transformation:** Transforming the API response into a consistent format for the client. * **Error Handling:** Handling errors from the API and returning appropriate error messages to the client. * **Configuration Manager:** A component that manages the configuration for all the APIs. This could be a simple file-based configuration (e.g., JSON, YAML) or a more sophisticated configuration management system (e.g., Consul, etcd). * **Middleware (Optional):** Middleware can be used to implement common features like authentication, authorization, rate limiting, and logging. * **Caching (Optional):** Caching API responses can improve performance and reduce the load on the target APIs. 3. **Implementation Steps (Python/Flask Example):** ```python # app.py (main application file) from flask import Flask, request, jsonify import importlib import os app = Flask(__name__) # Configuration directory CONFIG_DIR = "config" # Function to load API configuration def load_api_config(api_name): config_file = os.path.join(CONFIG_DIR, f"{api_name}.json") try: with open(config_file, "r") as f: import json return json.load(f) except FileNotFoundError: return None # API Router @app.route("/api/<api_name>/<path:api_path>", methods=['GET', 'POST', 'PUT', 'DELETE']) def api_proxy(api_name, api_path): # Load API configuration api_config = load_api_config(api_name) if not api_config: return jsonify({"error": f"API '{api_name}' not configured"}), 404 # Dynamically import the API handler module try: handler_module = importlib.import_module(f"api_handlers.{api_name}") handler = getattr(handler_module, "handle_request") # Assuming a handle_request function except (ImportError, AttributeError) as e: return jsonify({"error": f"Error loading API handler for '{api_name}': {e}"}), 500 # Prepare request data request_data = { "method": request.method, "path": api_path, "query_params": request.args.to_dict(), "body": request.get_json(), # Assuming JSON body "headers": dict(request.headers) } # Call the API handler try: response = handler(api_config, request_data) return jsonify(response["data"]), response["status_code"] except Exception as e: return jsonify({"error": f"Error processing request: {e}"}), 500 if __name__ == "__main__": # Create the config directory if it doesn't exist if not os.path.exists(CONFIG_DIR): os.makedirs(CONFIG_DIR) app.run(debug=True) ``` ```python # api_handlers/example_api.py (Example API handler) import requests def handle_request(api_config, request_data): """Handles requests for the Example API.""" base_url = api_config.get("base_url") api_key = api_config.get("api_key") if not base_url or not api_key: return {"status_code": 500, "data": {"error": "Missing API configuration"}} url = f"{base_url}/{request_data['path']}" headers = { "X-API-Key": api_key, "Content-Type": "application/json" # Adjust as needed } try: response = requests.request( request_data["method"], url, headers=headers, params=request_data["query_params"], json=request_data["body"] # Use data= for form data ) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) return {"status_code": response.status_code, "data": response.json()} except requests.exceptions.RequestException as e: return {"status_code": 500, "data": {"error": f"API request failed: {e}"}} ``` ```json # config/example_api.json (Example API configuration) { "base_url": "https://api.example.com", "api_key": "YOUR_API_KEY" } ``` **Explanation:** * **`app.py`:** * Sets up the Flask application. * Defines the `/api/<api_name>/<path:api_path>` route, which acts as the entry point for all API requests. * `load_api_config` function loads the API configuration from a JSON file. * Dynamically imports the API handler module based on the `api_name` from the URL. * Calls the `handle_request` function in the handler module. * Handles errors and returns the API response to the client. * **`api_handlers/example_api.py`:** * Contains the `handle_request` function, which is responsible for making the actual API call. * Loads the API configuration from the `api_config` dictionary. * Constructs the API URL. * Sets the necessary headers (including the API key). * Makes the HTTP request using the `requests` library. * Handles errors and returns the API response. * **`config/example_api.json`:** * Contains the API-specific configuration (base URL, API key, etc.). **Important:** Store API keys securely (e.g., using environment variables or a secrets management system). 4. **Configuration:** * Store API configurations in separate files (e.g., JSON, YAML) for each API. * Use environment variables or a secrets management system (e.g., HashiCorp Vault, AWS Secrets Manager) to store sensitive information like API keys. * Consider using a configuration management library (e.g., `python-decouple` in Python) to manage configuration settings. 5. **Error Handling:** * Implement robust error handling to catch exceptions and return informative error messages to the client. * Log errors for debugging and monitoring. 6. **Security:** * **API Key Protection:** Never hardcode API keys directly in the code. Use environment variables or a secrets management system. * **Input Validation:** Validate all incoming data to prevent injection attacks. * **Authentication and Authorization:** Implement authentication and authorization to control access to the APIs. * **HTTPS:** Use HTTPS to encrypt all traffic between the client and the server. 7. **Scalability:** * **Load Balancing:** Use a load balancer to distribute traffic across multiple instances of the server. * **Caching:** Cache API responses to reduce the load on the target APIs. * **Asynchronous Processing:** Use asynchronous tasks (e.g., Celery in Python) to handle long-running API calls. 8. **Deployment:** * Deploy the server to a cloud platform (e.g., AWS, Azure, Google Cloud) or a dedicated server. * Use a containerization technology like Docker to package the application and its dependencies. * Use a CI/CD pipeline to automate the deployment process. **Example Usage** To access the Example API, you would send a request to: ``` /api/example_api/users ``` This would be routed to the `api_handlers/example_api.py` module, which would then make a request to `https://api.example.com/users`. **Key Considerations** * **API Discovery:** How will clients know which APIs are available and how to use them? Consider providing an API catalog or documentation. * **Data Transformation:** You may need to transform data between different formats (e.g., JSON, XML, CSV). * **API Versioning:** How will you handle API versioning? Consider using URL-based versioning (e.g., `/api/v1/example_api/users`). * **Monitoring and Logging:** Implement monitoring and logging to track the performance of the server and identify potential issues. **Further Improvements** * **GraphQL:** Consider using GraphQL to provide a more flexible and efficient way for clients to query data from the APIs. * **API Gateway:** Use an API gateway (e.g., Kong, Tyk, AWS API Gateway) to handle routing, authentication, authorization, rate limiting, and other common API management tasks. * **OpenAPI (Swagger):** Use OpenAPI to define the API contract and generate documentation. **In Portuguese** Ok, entendo que você deseja criar um servidor MCP (Ponto Central Modificável) que possa lidar com solicitações para *qualquer* API. Este é um conceito amplo, então vamos detalhar os desafios e delinear uma possível abordagem. **Entendendo o Objetivo** A ideia central é construir um servidor flexível que atue como um ponto central para acessar várias APIs. Este servidor deve: * **Abstrair a Complexidade da API:** Ocultar os detalhes específicos de cada API dos clientes. * **Fornecer uma Interface Unificada:** Oferecer uma maneira consistente de interagir com diferentes APIs. * **Permitir Modificação/Adaptação:** Permitir que você altere facilmente como o servidor interage com as APIs subjacentes (por exemplo, alterar chaves de API, modificar parâmetros de solicitação, transformar respostas). * **Potencialmente Adicionar Recursos:** Implementar recursos como cache, limitação de taxa, autenticação e autorização. **Desafios** * **Diversidade de APIs:** As APIs têm diferentes métodos de autenticação, formatos de solicitação, estruturas de resposta, tratamento de erros e limites de taxa. * **Complexidade da Configuração:** Gerenciar a configuração para cada API pode se tornar complexo. * **Segurança:** Proteger as chaves de API e os dados confidenciais é crucial. * **Escalabilidade:** O servidor precisa lidar com um grande número de solicitações de forma eficiente. * **Manutenibilidade:** O código precisa ser bem estruturado e fácil de manter à medida que as APIs evoluem. **Possível Arquitetura e Implementação** Aqui está uma arquitetura de alto nível e um esboço de implementação usando Python e Flask (ou FastAPI) como exemplo. Você pode adaptar isso para outras linguagens e frameworks. 1. **Seleção do Framework:** * **Python (Flask ou FastAPI):** Boas opções para desenvolvimento rápido, flexibilidade e um grande ecossistema de bibliotecas. FastAPI é geralmente preferido por seu desempenho e validação automática de dados. * **Node.js (Express.js):** Outra opção popular, especialmente se você estiver confortável com JavaScript. * **Java (Spring Boot):** Uma escolha robusta para aplicações de nível empresarial. 2. **Componentes Principais:** * **Roteador/Despachante de API:** Este componente recebe as solicitações de entrada e as encaminha para o manipulador de API apropriado com base no caminho solicitado ou outros critérios. * **Módulos de Manipulador de API:** Cada API que você deseja suportar terá seu próprio módulo de manipulador. Este módulo é responsável por: * **Configuração:** Carregar a configuração específica da API (chaves de API, URLs base, etc.). * **Transformação de Solicitação:** Transformar a solicitação de entrada no formato esperado pela API de destino. * **Chamada de API:** Fazer a solicitação HTTP real para a API de destino. * **Transformação de Resposta:** Transformar a resposta da API em um formato consistente para o cliente. * **Tratamento de Erros:** Lidar com erros da API e retornar mensagens de erro apropriadas para o cliente. * **Gerenciador de Configuração:** Um componente que gerencia a configuração para todas as APIs. Isso pode ser uma configuração simples baseada em arquivo (por exemplo, JSON, YAML) ou um sistema de gerenciamento de configuração mais sofisticado (por exemplo, Consul, etcd). * **Middleware (Opcional):** O middleware pode ser usado para implementar recursos comuns como autenticação, autorização, limitação de taxa e registro. * **Cache (Opcional):** Armazenar em cache as respostas da API pode melhorar o desempenho e reduzir a carga nas APIs de destino. 3. **Etapas de Implementação (Exemplo Python/Flask):** ```python # app.py (arquivo principal da aplicação) from flask import Flask, request, jsonify import importlib import os app = Flask(__name__) # Diretório de configuração CONFIG_DIR = "config" # Função para carregar a configuração da API def load_api_config(api_name): config_file = os.path.join(CONFIG_DIR, f"{api_name}.json") try: with open(config_file, "r") as f: import json return json.load(f) except FileNotFoundError: return None # Roteador de API @app.route("/api/<api_name>/<path:api_path>", methods=['GET', 'POST', 'PUT', 'DELETE']) def api_proxy(api_name, api_path): # Carregar a configuração da API api_config = load_api_config(api_name) if not api_config: return jsonify({"error": f"API '{api_name}' não configurada"}), 404 # Importar dinamicamente o módulo do manipulador de API try: handler_module = importlib.import_module(f"api_handlers.{api_name}") handler = getattr(handler_module, "handle_request") # Assumindo uma função handle_request except (ImportError, AttributeError) as e: return jsonify({"error": f"Erro ao carregar o manipulador de API para '{api_name}': {e}"}), 500 # Preparar os dados da solicitação request_data = { "method": request.method, "path": api_path, "query_params": request.args.to_dict(), "body": request.get_json(), # Assumindo corpo JSON "headers": dict(request.headers) } # Chamar o manipulador de API try: response = handler(api_config, request_data) return jsonify(response["data"]), response["status_code"] except Exception as e: return jsonify({"error": f"Erro ao processar a solicitação: {e}"}), 500 if __name__ == "__main__": # Criar o diretório de configuração se ele não existir if not os.path.exists(CONFIG_DIR): os.makedirs(CONFIG_DIR) app.run(debug=True) ``` ```python # api_handlers/example_api.py (Manipulador de API de Exemplo) import requests def handle_request(api_config, request_data): """Manipula solicitações para a API de Exemplo.""" base_url = api_config.get("base_url") api_key = api_config.get("api_key") if not base_url or not api_key: return {"status_code": 500, "data": {"error": "Configuração da API ausente"}} url = f"{base_url}/{request_data['path']}" headers = { "X-API-Key": api_key, "Content-Type": "application/json" # Ajuste conforme necessário } try: response = requests.request( request_data["method"], url, headers=headers, params=request_data["query_params"], json=request_data["body"] # Use data= para dados de formulário ) response.raise_for_status() # Levantar HTTPError para respostas ruins (4xx ou 5xx) return {"status_code": response.status_code, "data": response.json()} except requests.exceptions.RequestException as e: return {"status_code": 500, "data": {"error": f"Falha na solicitação da API: {e}"}} ``` ```json # config/example_api.json (Configuração da API de Exemplo) { "base_url": "https://api.example.com", "api_key": "SUA_CHAVE_DE_API" } ``` **Explicação:** * **`app.py`:** * Configura a aplicação Flask. * Define a rota `/api/<api_name>/<path:api_path>`, que atua como o ponto de entrada para todas as solicitações de API. * A função `load_api_config` carrega a configuração da API de um arquivo JSON. * Importa dinamicamente o módulo do manipulador de API com base no `api_name` da URL. * Chama a função `handle_request` no módulo do manipulador. * Lida com erros e retorna a resposta da API para o cliente. * **`api_handlers/example_api.py`:** * Contém a função `handle_request`, que é responsável por fazer a chamada de API real. * Carrega a configuração da API do dicionário `api_config`. * Constrói a URL da API. * Define os cabeçalhos necessários (incluindo a chave de API). * Faz a solicitação HTTP usando a biblioteca `requests`. * Lida com erros e retorna a resposta da API. * **`config/example_api.json`:** * Contém a configuração específica da API (URL base, chave de API, etc.). **Importante:** Armazene as chaves de API com segurança (por exemplo, usando variáveis de ambiente ou um sistema de gerenciamento de segredos). 4. **Configuração:** * Armazene as configurações da API em arquivos separados (por exemplo, JSON, YAML) para cada API. * Use variáveis de ambiente ou um sistema de gerenciamento de segredos (por exemplo, HashiCorp Vault, AWS Secrets Manager) para armazenar informações confidenciais, como chaves de API. * Considere usar uma biblioteca de gerenciamento de configuração (por exemplo, `python-decouple` em Python) para gerenciar as configurações. 5. **Tratamento de Erros:** * Implemente um tratamento de erros robusto para capturar exceções e retornar mensagens de erro informativas para o cliente. * Registre os erros para depuração e monitoramento. 6. **Segurança:** * **Proteção da Chave de API:** Nunca codifique chaves de API diretamente no código. Use variáveis de ambiente ou um sistema de gerenciamento de segredos. * **Validação de Entrada:** Valide todos os dados de entrada para evitar ataques de injeção. * **Autenticação e Autorização:** Implemente autenticação e autorização para controlar o acesso às APIs. * **HTTPS:** Use HTTPS para criptografar todo o tráfego entre o cliente e o servidor. 7. **Escalabilidade:** * **Balanceamento de Carga:** Use um balanceador de carga para distribuir o tráfego entre várias instâncias do servidor. * **Cache:** Armazene em cache as respostas da API para reduzir a carga nas APIs de destino. * **Processamento Assíncrono:** Use tarefas assíncronas (por exemplo, Celery em Python) para lidar com chamadas de API de longa duração. 8. **Implantação:** * Implante o servidor em uma plataforma de nuvem (por exemplo, AWS, Azure, Google Cloud) ou em um servidor dedicado. * Use uma tecnologia de contêinerização como o Docker para empacotar a aplicação e suas dependências. * Use um pipeline CI/CD para automatizar o processo de implantação. **Exemplo de Uso** Para acessar a API de Exemplo, você enviaria uma solicitação para: ``` /api/example_api/users ``` Isso seria roteado para o módulo `api_handlers/example_api.py`, que então faria uma solicitação para `https://api.example.com/users`. **Considerações Chave** * **Descoberta de API:** Como os clientes saberão quais APIs estão disponíveis e como usá-las? Considere fornecer um catálogo de API ou documentação. * **Transformação de Dados:** Você pode precisar transformar dados entre diferentes formatos (por exemplo, JSON, XML, CSV). * **Versionamento de API:** Como você lidará com o versionamento de API? Considere usar o versionamento baseado em URL (por exemplo, `/api/v1/example_api/users`). * **Monitoramento e Registro:** Implemente monitoramento e registro para rastrear o desempenho do servidor e identificar possíveis problemas. **Melhorias Adicionais** * **GraphQL:** Considere usar GraphQL para fornecer uma maneira mais flexível e eficiente para os clientes consultarem dados das APIs. * **Gateway de API:** Use um gateway de API (por exemplo, Kong, Tyk, AWS API Gateway) para lidar com roteamento, autenticação, autorização, limitação de taxa e outras tarefas comuns de gerenciamento de API. * **OpenAPI (Swagger):** Use OpenAPI para definir o contrato da API e gerar documentação. This detailed explanation and code example should give you a solid foundation for building your MCP server. Remember to adapt the code to your specific needs and API requirements. Good luck!

Console MCP Server

Captures and stores console output from any process in SQLite with full-text search, enabling AI assistants to search logs, monitor errors, and analyze multi-process activity through natural language queries.

syplugin-anMCPServer

A Model Context Protocol server plugin for SiYuan note-taking application that enables searching documents, retrieving content, and writing to notes through an HTTP-based interface.

CodeLogic

Interaja com o CodeLogic, uma plataforma de Inteligência de Software que mapeia dependências complexas de arquiteturas de código e dados, para impulsionar a precisão e o conhecimento da IA.

YouTrack MCP Server

A comprehensive Model Context Protocol server for YouTrack integration, providing extensive tools for issue tracking, project management, workflow automation, and team collaboration.

TwitterAPI MCP Server

An MCP server that provides access to Twitter data and write actions through TwitterAPI.io, bypassing the need for a standard Twitter developer account. It enables users to search tweets, retrieve profiles, and post content with support for pagination and enterprise proxy configurations.

New Relic MCP Server

Enables AI assistants to interact with New Relic monitoring and observability data through programmatic access to New Relic APIs. Supports APM management, NRQL queries, alert policies, synthetic monitoring, dashboards, infrastructure monitoring, and deployment tracking.

Inbox MCP

Transform your inbox into an intelligent, LLM-powered assistant that manages, organizes, and streamlines email using conversational language. Compatible with Gmail, Outlook, iCloud, Yahoo, and IMAP services through Nylas v3 API.

Notion Knowledge MCP Server

A Cloudflare Workers-based service that enables intelligent searching, automatic code snippet recording, and statistical analysis of programming knowledge stored in Notion databases.

DataMerge MCP

Enables AI assistants to enrich and retrieve company data by connecting to the DataMerge Company API. It supports operations such as starting enrichment jobs, fetching company records, and inspecting corporate hierarchies.

A-MEM: Agentic Memory System

Provides an intelligent, graph-based memory system for LLM agents using the Zettelkasten principle, enabling automatic note construction, semantic linking, memory evolution, and autonomous graph maintenance with background optimization processes.

Ontology MCP

A Model Context Protocol (MCP) server that connects GraphDB's SPARQL endpoints and Ollama models to Claude, enabling Claude to query and manipulate ontology data while leveraging various AI models.

MCP Google Sheets Server

Servidor de Protocolo de Contexto do Modelo (MCP) que permite a interação com o Google Sheets

Tilt MCP Server

Enables AI assistants to interact with Tilt development workflows, including monitoring resource status, managing resources (enable/disable/trigger), accessing logs, and configuring Tiltfile arguments through natural language.

MCP Server for OSCAL

Provides AI assistants with specialized tools to interact with NIST's Open Security Controls Assessment Language (OSCAL) framework. It enables agents to retrieve schemas, explore models, and generate valid OSCAL documentation for security compliance automation.

RunPod MCP Server

Este servidor de Protocolo de Contexto do Modelo (MCP) permite a interação com a API REST da RunPod através do Claude ou outros clientes compatíveis com MCP, fornecendo ferramentas para gerenciar pods, endpoints, templates, volumes de rede e autenticações de registro de contêineres.

Gmail API MCP Server

A Model Context Protocol server that enables interaction with the Gmail API through natural language, auto-generated using AG2's MCP builder.

GlitchTip MCP Server

Integrates GlitchTip error monitoring with AI assistants to fetch, analyze, and debug production errors. It enables users to list issues, retrieve event details, and perform guided triage of application errors through natural language.

AgentGo MCP Service

A Model Context Protocol service that enables agent authentication and integration with TrustGo platform, providing access to real-time data like price, sigma score, and mindshare bubble analytics.

Neo4j GraphRAG MCP Server

An MCP server that enables LLMs to perform semantic and fulltext searches within Neo4j while executing complex, search-augmented Cypher queries for GraphRAG applications. It provides tools for database schema discovery and supports multi-provider embeddings to facilitate advanced graph traversals.

BlobGuard MCP

A lightweight, multi-tenant blob storage and diff server that helps LLM coding agents manage large code edits while reducing hallucinations and maintaining work integrity.

M/M/1 Queue Simulation Server

Provides comprehensive M/M/1 queuing system simulation capabilities including theoretical calculations, parameter validation, SimPy simulation execution, and comparison of simulation results with theoretical metrics.

Simple MCP Server

A lightweight Model Context Protocol server that provides an in-memory key-value store with get, set, delete, list, and clear operations for MCP-compatible AI assistants and clients.

Google Search Console MCP Server

Servidor MCP para integração da API Google Search Console com n8n.

Reckon MCP Server by CData

This read-only MCP Server allows you to connect to Reckon data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

NPM Context Agent MCP

Provides comprehensive contextual information about npm packages including README files, versions, dependencies, download statistics, and search functionality. Enables users to explore and analyze npm packages through natural language queries with intelligent GitHub README fetching and branch fallback.

sentry-selfhosted-mcp

An MCP server for self-hosted sentry.