Discover Awesome MCP Servers

MCP for IIIF Images

Provides tools to fetch IIIF manifests and retrieve specific image regions or scaled images for analysis. This server enables detailed interaction with International Image Interoperability Framework resources, supporting tasks like image description and transcription.

MeshAI MCP Server

Enables Claude Code and other MCP-compatible tools to leverage MeshAI's multi-agent orchestration capabilities for code review, refactoring, debugging, documentation, architecture analysis, and feature development. Automatically selects appropriate AI agents based on task content and works with agents built on LangChain, CrewAI, AutoGen, and other frameworks.

QMD - Query Markdown

Provides hybrid search over local markdown knowledge bases using BM25 keyword search and vector semantic search. Enables indexing, querying, and retrieving markdown documentation with dual-mode support for local and remote agents.

CATA Bus MCP Server

Provides real-time and scheduled bus data for the Centre Area Transportation Authority (CATA) in State College, PA. Enables users to track live bus positions, get arrival predictions, search stops, view routes, and receive service alerts through natural language queries.

Graphiti MCP Pro

Enhanced memory repository MCP service that enables building and querying temporally-aware knowledge graphs from user interactions and enterprise data. Features asynchronous processing, task management tools, multi-model compatibility, and a comprehensive visual management interface.

Facebook Ads MCP Server

Connects AI assistants to Facebook's Ads API to enable natural language queries for campaign data, insights, and performance metrics. It allows users to manage ad accounts and retrieve detailed analytics like impressions, clicks, and spend through MCP-compatible interfaces.

Dynamic Per-User Tool Generation MCP Server

Enables dynamic generation of tools based on user-specific permissions from an external API. Users receive personalized tools tailored to their access rights, with intelligent caching and graceful fallback to static tools.

StashDog MCP Server

Enables AI assistants to manage StashDog inventory through natural language commands, supporting item management, collections, tags, smart search, and URL imports with secure authentication.

Updation MCP

A production-grade, LLM-agnostic MCP server that integrates AI models with tools for managing subscriptions, organizations, and payments via the Updation API. It features Redis-backed conversation memory, structured logging, and role-based access control for secure, scalable orchestration.

iMessage MCP Server

Enables Claude to read and search through iMessage, SMS, and RCS conversations, including mixed-protocol group chats with Android users. It decodes binary message data from the macOS Messages database to provide a comprehensive view of message history.

MCP Fantastical Server

Enables natural language calendar management through Fantastical on macOS, allowing users to create events, view schedules, search appointments, and navigate their calendar without leaving their AI conversation.

SiYuan Note MCP Server

Espelho de

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.

Bluesky MCP Server

Enables AI agents to interact with Bluesky social network through optimized, token-efficient tools for posting, replying, searching, and managing social relationships. Features Windows-compatible implementation with context cleanup to minimize LLM token consumption.

MCP Basics

A centralized Model Context Protocol server that provides common development tools (like formatting and translation) across all your Cline projects without needing to install them individually.

Vimango MCP Server

Enables Claude to create and organize markdown research notes directly in your local vimango SQLite databases, with support for contexts, folders, and automatic synchronization.

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.

Korea Tourism API MCP Server

Permite que assistentes de IA acessem informações turísticas da Coreia do Sul através da API oficial da Organização de Turismo da Coreia, fornecendo uma pesquisa abrangente de atrações, eventos, comida e acomodações com suporte multilíngue.

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.

Crawl4AI RAG MCP Server

Provides AI agents and coding assistants with advanced web crawling and RAG capabilities, allowing them to scrape websites and leverage that knowledge through various retrieval strategies.

Sketchup Integration

Conecta o SketchUp ao Claude AI através do Protocolo de Contexto do Modelo, permitindo que o Claude interaja diretamente e controle o SketchUp para modelagem 3D assistida por prompts e manipulação de cenas.

Garza Home MCP

Personal home automation server integrating unified messaging (Beeper), home security (Abode), UniFi cameras/sensors, ProtonMail, knowledge graphs (Graphiti), Bible resources, and push notifications across 49 tools.

etsy-mcp-server

Servidor MCP para integrar com o Etsy

Jira MCP Server

Enables comprehensive interaction with self-hosted Jira instances using Personal Access Token authentication, supporting issue management, JQL searches, comments, transitions, projects, and custom fields through 27 specialized tools.