Discover Awesome MCP Servers

Anam MCP Server

Enables managing AI personas, avatars, voices, and sessions from any MCP client, for integration with Anam AI.

mcp-sketch

Local MCP server for parsing Sketch exported HTML zip archives and extracting design structure information.

intercept-mcp

Give your AI the ability to read the web. Fetches URLs as clean markdown with 9 fallback strategies.

report-mcp

Enables filling uploaded document templates (DOCX/HWP/HWPX/PDF) with chatbot-generated content while preserving original formatting, tables, and images, and saving as files.

Cortex MCP Server

Cortex MCP provides AI agents with long-term portfolio memory by transforming project history and developer decisions into a structured, queryable knowledge graph. It enables assistants to maintain context across different repositories by exposing historical patterns, architectural decisions, and technology preferences through the Model Context Protocol.

Prizmad

Generate AI UGC video ads from any product URL in 5 minutes. Realistic AI avatars, natural voiceover, proven ad templates. No actors, no editing, no experience required.

EdgeOne Geo MCP Server

Enables AI models to access user geolocation information through EdgeOne Pages Functions, allowing location-aware AI interactions.

Cloudflare Playwright MCP

Enables AI assistants to control a browser through Playwright on Cloudflare Workers, allowing web automation tasks like navigation, typing, clicking, and taking screenshots through natural language commands.

Typefully MCP Server

A Model Context Protocol server that enables AI assistants to create and manage Twitter drafts on Typefully, supporting features like thread creation, scheduling, and retrieving published content.

Barebones MCP Server

A minimal, dockerized template for creating HTTP-based Model Context Protocol servers. Provides a starting point with FastMCP framework integration and includes a sample cat fact tool that can be replaced with custom functionality.

HubSpot MCP Server

Enables interaction with HubSpot CRM to create, update, delete, and fetch summary records stored as Note engagements, with support for filtering by date and sharing via chat or email.

XiaoZhi MCP Aggregate

A powerful interface for extending AI capabilities through remote control, calculations, email operations, knowledge search, and more.

PubMed MCP Server

Enables comprehensive biomedical literature research through PubMed database access with advanced search, full-text retrieval, citation analysis, and batch processing capabilities. Supports both local deployment and cloud hosting for seamless integration with AI assistants.

MCP Docs Provider

Enables AI models to seamlessly access and query local markdown technical documentation files, providing automatic documentation context without explicit prompting.

3D-MCP

A universal Model Context Protocol implementation that serves as a semantic layer between LLMs and 3D creative software, providing a standardized interface for interacting with various Digital Content Creation tools through a unified API.

redmine-mcp-server

Enables AI assistants to interact with Redmine for task management, time logging, status updates, and progress tracking via the MCP protocol.

Forge

Terminal MCP server for AI coding agents with persistent PTY sessions, ring-buffer incremental reads, headless xterm screen capture, multi-agent orchestration, and a real-time web dashboard.

REAPER MCP Server

A Model Context Protocol server that enables AI agents to create fully mixed and mastered tracks in REAPER DAW, supporting project management, MIDI composition, audio recording, and mixing automation.

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!

Name.com MCP Server

Enables management of domains and DNS records through the Name.com REST API. Users can search for available domains, check bulk availability, and configure DNS records or nameservers using natural language.

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.

Travel MCP Server

Enables travel package management, booking, and itinerary planning through MCP-compliant endpoints with 26 tools for searching, comparing, and booking travel packages.

kernel-build-mcp

An MCP server designed for remote Linux kernel cross-compilation over Tailscale SSH. It enables users to manage configurations, execute kernel builds, and retrieve build artifacts directly through an MCP-compatible interface.

Smart Connections MCP Server

Enables semantic search and knowledge graph exploration of Obsidian vaults using Smart Connections embeddings. Provides intelligent note discovery, similarity search, and connection mapping through natural language queries.

Document360 MCP Server

Enables access to Document360 knowledge base content through simple GET operations. Allows searching, browsing categories, and reading articles from Document360 projects using natural language.

MCP Server for CAP

Enables Claude to interact with a document processing backend, providing tools for listing, retrieving, uploading, and processing documents, as well as resources for pending documents and statistics.

exchangerate

Provides real-time exchange rates for any currency pair using open.er-api.com, simplifying currency conversion with a single tool.