Discover Awesome MCP Servers

mcp-servers

A collection of MCP server tools in Typescript

MCP - My Favorite MCP Servers

Uma coleção dos meus servidores MCP (Master Control Program) favoritos.

repo-template

A Python server implementation for Feishu (Lark) bot that follows the Model Context Protocol (MCP). This server provides a standardized interface for handling automated messaging and context-aware interactions within enterprise Feishu environments.

Ads Manager MCP server for Claude

Permite que os usuários analisem, gerenciem e otimizem campanhas de publicidade digital por meio de conversas em linguagem natural no Claude, oferecendo insights de desempenho, visualizações interativas e gerenciamento de campanhas para plataformas como o Amazon Ads.

Deepseek R1 MCP Server

Espelho de

Whisper_King

Repository created by MCP server

Analytical MCP Server

Fornece capacidades avançadas de análise, pesquisa e processamento de linguagem natural através de um servidor de Protocolo de Contexto de Modelo, permitindo análise de conjuntos de dados, análise de decisão e recursos aprimorados de PNL, como reconhecimento de entidades e extração de fatos.

Clever Cloud Documentation MCP server

Mirror of

MCP Server

Teste de servidor MCP que pode fazer várias coisas.

Share MCP - Model Context Protocol 导航站

Share MCP é um site de navegação focado no Model Context Protocol (MCP). Ele oferece uma rica exibição categorizada de recursos, ferramentas e serviços relacionados ao MCP, ajudando os desenvolvedores a encontrar rapidamente as soluções de MCP de que precisam.

LivebookTools

Powertools for livebook.dev — AI Code Editing, MCP Servers, and Running Livebooks from the CLI

esa-mcp-server

Mirror of

Agent Construct

Uma implementação de servidor MCP que padroniza como aplicações de IA acessam ferramentas e contexto, fornecendo um hub central que gerencia a descoberta, execução e gerenciamento de contexto de ferramentas com um sistema de configuração simplificado.

Salesforce MCP Server

Mirror of

MCP Documentation Search Server

🔍 FastMCP-powered documentation search engine that provides unified access to multiple framework docs (Next.js, Tailwind, Framer Motion, etc.) with intelligent name resolution and async processing.

MCP Server Office

Um servidor que fornece ferramentas para ler, escrever e editar arquivos do Microsoft Word (docx) através do Protocolo de Contexto de Modelo, permitindo operações como leitura completa do documento, criação de conteúdo, edição direcionada de parágrafos e inserção de texto.

Maven Dependencies MCP Server

Mirror of

Text2sim MCP Server

Text2Sim MCP Server é um mecanismo de simulação de eventos discretos que gera e executa modelos flexíveis baseados em SimPy a partir de descrições em linguagem natural. Suporta fluxos de trabalho multi-domínio (aeroporto, saúde, manufatura) com entidades configuráveis, lógica estocástica e métricas em tempo real.

MCP Analysis Templates

Servidor MCP para gerenciar e servir modelos de prompts de análise.

Firecrawl MCP Server

Espelho de

Supabase MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que Claude e outros LLMs realizem operações de banco de dados e invoquem Funções de Borda dentro do Supabase através de linguagem natural.

MCP Server Example

Here's a basic outline of an MCP (Minecraft Protocol) server template that can be integrated with Cursor to enable AI tools like weather information retrieval using the Claude-3.7-sonnet model. This is a high-level overview; implementing a full MCP server is a complex task. This template focuses on the core structure and integration points. **Conceptual Overview** 1. **MCP Server Core:** Handles the Minecraft protocol, player connections, and basic game logic. 2. **Cursor Integration:** Provides an API endpoint or mechanism for Cursor to send commands to the server. 3. **AI Integration (Claude-3.7-sonnet):** Uses the Claude-3.7-sonnet model (via an API) to process commands and retrieve information (e.g., weather). 4. **Command Handling:** Parses commands received from Cursor, triggers AI requests, and sends responses back to the Minecraft client. **Template Structure (Python - Example)** ```python # mcp_server.py import socket import threading import json import requests # For making API calls to Claude # Configuration HOST = '127.0.0.1' # Localhost PORT = 25565 # Minecraft default port (can be changed) CLAUDE_API_KEY = "YOUR_CLAUDE_API_KEY" # Replace with your actual API key CLAUDE_API_ENDPOINT = "https://api.anthropic.com/v1/messages" # Example endpoint # --- Minecraft Protocol Handling (Simplified) --- def handle_client(conn, addr): print(f"Connected by {addr}") try: while True: data = conn.recv(1024) # Receive data from the client if not data: break # Decode the data (assuming UTF-8 encoding) message = data.decode('utf-8').strip() print(f"Received from client: {message}") # Process the message (e.g., check for commands) response = process_message(message) # Send the response back to the client conn.sendall(response.encode('utf-8')) except Exception as e: print(f"Error handling client: {e}") finally: print(f"Closing connection with {addr}") conn.close() # --- Command Processing and AI Integration --- def process_message(message): """ Processes messages received from the Minecraft client. This is where you'd parse commands and trigger AI requests. """ if message.startswith("/weather"): location = message[len("/weather"):].strip() # Extract location if not location: return "Please specify a location. Example: /weather London" weather_data = get_weather_from_claude(location) if weather_data: return f"Weather in {location}: {weather_data}" else: return "Could not retrieve weather information." elif message.startswith("/cursor"): # Example: /cursor do something command = message[len("/cursor"):].strip() return f"Cursor command received: {command}. (This is a placeholder)" else: return "Unknown command." def get_weather_from_claude(location): """ Retrieves weather information from Claude-3.7-sonnet. """ try: headers = { "Content-Type": "application/json", "x-api-key": CLAUDE_API_KEY, "anthropic-version": "2023-06-01" # Or the appropriate version } data = { "model": "claude-3.5-sonnet-20240620", # Use the correct model name "max_tokens": 200, "messages": [ { "role": "user", "content": f"What is the current weather in {location}? Give a brief summary." } ] } response = requests.post(CLAUDE_API_ENDPOINT, headers=headers, json=data) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) json_response = response.json() # Extract the weather information from the Claude response # This will depend on the exact format of Claude's response. # You might need to adjust this part. weather_summary = json_response['content'][0]['text'] # Example return weather_summary except requests.exceptions.RequestException as e: print(f"Error calling Claude API: {e}") return None except (KeyError, TypeError) as e: print(f"Error parsing Claude response: {e}") return None # --- Cursor Integration (Placeholder) --- # This is where you'd add an API endpoint or other mechanism # for Cursor to send commands to the server. # For example, a simple HTTP endpoint using Flask or FastAPI. # The process_message function would then handle commands received from Cursor. # --- Server Setup --- def start_server(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((HOST, PORT)) server_socket.listen() print(f"Server listening on {HOST}:{PORT}") try: while True: conn, addr = server_socket.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() except KeyboardInterrupt: print("Server shutting down.") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **Explanation and Key Considerations:** * **Minecraft Protocol:** This example *does not* implement the full Minecraft protocol. That's a very complex undertaking. It simply receives and sends UTF-8 encoded strings. To properly interact with a Minecraft client, you'll need to implement the protocol (packet handling, compression, encryption, etc.). Libraries like `mcstatus` or `python-minecraft-protocol` can help. Consider using a pre-built Minecraft server implementation (like a modified Spigot plugin or a custom server based on a library) for a more robust solution. * **Command Handling:** The `process_message` function is the core of the command processing. It parses commands and calls the appropriate functions. You'll need to expand this to handle more commands and logic. * **Claude Integration:** The `get_weather_from_claude` function makes an API call to Claude-3.7-sonnet. **Important:** * **API Key:** Replace `"YOUR_CLAUDE_API_KEY"` with your actual Claude API key. * **Endpoint:** Verify the correct Claude API endpoint. * **Model Name:** Use the correct model name (e.g., `"claude-3.5-sonnet-20240620"`). Model names can change. * **Error Handling:** The code includes basic error handling for API requests and response parsing. Improve this for production use. * **Rate Limiting:** Be aware of Claude's API rate limits and implement appropriate handling to avoid exceeding them. * **Prompt Engineering:** The prompt sent to Claude ("What is the current weather in {location}? Give a brief summary.") is crucial. Experiment with different prompts to get the best results. * **Response Parsing:** The code assumes a specific format for Claude's response. You'll need to adjust the `weather_summary = json_response['content'][0]['text']` line to match the actual response format. Use `print(json_response)` to inspect the response. * **Cursor Integration:** This is a placeholder. You'll need to decide how Cursor will communicate with the server. Possible options: * **HTTP Endpoint:** Create a simple HTTP endpoint (using Flask or FastAPI) that Cursor can send commands to. The server would then process these commands and send responses back to the Minecraft client. * **WebSockets:** Use WebSockets for real-time communication between Cursor and the server. * **Message Queue (e.g., RabbitMQ, Redis Pub/Sub):** Use a message queue for asynchronous communication. * **Threading:** The server uses threads to handle multiple client connections concurrently. * **Security:** This is a very basic example and lacks security measures. For a production server, you'll need to implement proper authentication, authorization, and input validation to prevent security vulnerabilities. * **Error Handling:** The error handling is basic. Improve it to provide more informative error messages and handle different types of errors gracefully. * **Minecraft Protocol Implementation:** As mentioned before, this is the biggest challenge. You'll likely need to use a library or framework to handle the Minecraft protocol correctly. * **Asynchronous Operations:** Consider using asynchronous programming (e.g., `asyncio` in Python) for better performance, especially when making API calls to Claude. **How to Integrate with Cursor:** 1. **Choose a Communication Method:** Decide how Cursor will send commands to the server (HTTP, WebSockets, message queue). 2. **Implement the API:** Create the necessary API endpoint or mechanism on the server to receive commands from Cursor. 3. **Send Commands from Cursor:** Configure Cursor to send commands to the server's API. This might involve writing a Cursor extension or using Cursor's built-in scripting capabilities. 4. **Process Commands:** In the `process_message` function, handle the commands received from Cursor. 5. **Send Responses:** Send responses back to the Minecraft client (or to Cursor, depending on the communication method). **Example Cursor Integration (HTTP Endpoint using Flask):** ```python # (Add to the mcp_server.py file) from flask import Flask, request app = Flask(__name__) @app.route('/cursor_command', methods=['POST']) def cursor_command(): data = request.get_json() command = data.get('command') if command: response = process_message(f"/cursor {command}") # Simulate a /cursor command return response, 200 else: return "No command provided", 400 # Modify the start_server function to run the Flask app in a separate thread def start_server(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((HOST, PORT)) server_socket.listen() print(f"Server listening on {HOST}:{PORT}") # Start the Flask app in a separate thread flask_thread = threading.Thread(target=app.run, kwargs={'host': '0.0.0.0', 'port': 5000, 'debug': False, 'use_reloader': False}) # Choose a different port for Flask flask_thread.daemon = True # Allow the main thread to exit even if the Flask thread is running flask_thread.start() try: while True: conn, addr = server_socket.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() except KeyboardInterrupt: print("Server shutting down.") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **In Cursor:** You would then use a tool like `curl` or `requests` (within a Cursor extension or script) to send a POST request to `http://localhost:5000/cursor_command` with a JSON payload like: ```json { "command": "do something" } ``` **Important Notes:** * This is a very simplified example. Building a full-fledged MCP server with AI integration is a significant project. * Focus on implementing the Minecraft protocol correctly first. * Start with a simple command (like weather retrieval) and gradually add more features. * Thoroughly test your code and handle errors gracefully. * Consider using a more robust framework or library for building the server. * Pay close attention to security best practices. This detailed template provides a solid foundation for building your MCP server with Cursor and Claude integration. Remember to adapt it to your specific needs and requirements. Good luck! **Tradução para Português:** Aqui está um esboço básico de um modelo de servidor MCP (Minecraft Protocol) que pode ser integrado com o Cursor para habilitar ferramentas de IA como a recuperação de informações meteorológicas usando o modelo Claude-3.7-sonnet. Esta é uma visão geral de alto nível; implementar um servidor MCP completo é uma tarefa complexa. Este modelo se concentra na estrutura central e nos pontos de integração. **Visão Geral Conceitual** 1. **Núcleo do Servidor MCP:** Lida com o protocolo Minecraft, conexões de jogadores e lógica básica do jogo. 2. **Integração com o Cursor:** Fornece um endpoint de API ou mecanismo para o Cursor enviar comandos para o servidor. 3. **Integração de IA (Claude-3.7-sonnet):** Usa o modelo Claude-3.7-sonnet (via uma API) para processar comandos e recuperar informações (por exemplo, clima). 4. **Manipulação de Comandos:** Analisa os comandos recebidos do Cursor, aciona solicitações de IA e envia respostas de volta para o cliente Minecraft. **Estrutura do Modelo (Python - Exemplo)** ```python # mcp_server.py import socket import threading import json import requests # Para fazer chamadas de API para o Claude # Configuração HOST = '127.0.0.1' # Localhost PORT = 25565 # Porta padrão do Minecraft (pode ser alterada) CLAUDE_API_KEY = "SUA_CHAVE_API_CLAUDE" # Substitua pela sua chave API real CLAUDE_API_ENDPOINT = "https://api.anthropic.com/v1/messages" # Exemplo de endpoint # --- Manipulação do Protocolo Minecraft (Simplificado) --- def handle_client(conn, addr): print(f"Conectado por {addr}") try: while True: data = conn.recv(1024) # Recebe dados do cliente if not data: break # Decodifica os dados (assumindo codificação UTF-8) message = data.decode('utf-8').strip() print(f"Recebido do cliente: {message}") # Processa a mensagem (por exemplo, verifica por comandos) response = process_message(message) # Envia a resposta de volta para o cliente conn.sendall(response.encode('utf-8')) except Exception as e: print(f"Erro ao lidar com o cliente: {e}") finally: print(f"Fechando a conexão com {addr}") conn.close() # --- Processamento de Comandos e Integração de IA --- def process_message(message): """ Processa mensagens recebidas do cliente Minecraft. É aqui que você analisaria os comandos e acionaria as solicitações de IA. """ if message.startswith("/weather"): location = message[len("/weather"):].strip() # Extrai a localização if not location: return "Por favor, especifique uma localização. Exemplo: /weather Londres" weather_data = get_weather_from_claude(location) if weather_data: return f"Clima em {location}: {weather_data}" else: return "Não foi possível recuperar informações meteorológicas." elif message.startswith("/cursor"): # Exemplo: /cursor faça algo command = message[len("/cursor"):].strip() return f"Comando do Cursor recebido: {command}. (Este é um espaço reservado)" else: return "Comando desconhecido." def get_weather_from_claude(location): """ Recupera informações meteorológicas do Claude-3.7-sonnet. """ try: headers = { "Content-Type": "application/json", "x-api-key": CLAUDE_API_KEY, "anthropic-version": "2023-06-01" # Ou a versão apropriada } data = { "model": "claude-3.5-sonnet-20240620", # Use o nome do modelo correto "max_tokens": 200, "messages": [ { "role": "user", "content": f"Qual é o clima atual em {location}? Dê um breve resumo." } ] } response = requests.post(CLAUDE_API_ENDPOINT, headers=headers, json=data) response.raise_for_status() # Lança HTTPError para respostas ruins (4xx ou 5xx) json_response = response.json() # Extrai as informações meteorológicas da resposta do Claude # Isso dependerá do formato exato da resposta do Claude. # Você pode precisar ajustar esta parte. weather_summary = json_response['content'][0]['text'] # Exemplo return weather_summary except requests.exceptions.RequestException as e: print(f"Erro ao chamar a API do Claude: {e}") return None except (KeyError, TypeError) as e: print(f"Erro ao analisar a resposta do Claude: {e}") return None # --- Integração com o Cursor (Espaço Reservado) --- # É aqui que você adicionaria um endpoint de API ou outro mecanismo # para o Cursor enviar comandos para o servidor. # Por exemplo, um endpoint HTTP simples usando Flask ou FastAPI. # A função process_message então lidaria com os comandos recebidos do Cursor. # --- Configuração do Servidor --- def start_server(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((HOST, PORT)) server_socket.listen() print(f"Servidor ouvindo em {HOST}:{PORT}") try: while True: conn, addr = server_socket.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() except KeyboardInterrupt: print("Servidor desligando.") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **Explicação e Considerações Chave:** * **Protocolo Minecraft:** Este exemplo *não* implementa o protocolo Minecraft completo. Essa é uma tarefa muito complexa. Ele simplesmente recebe e envia strings codificadas em UTF-8. Para interagir corretamente com um cliente Minecraft, você precisará implementar o protocolo (manipulação de pacotes, compressão, criptografia, etc.). Bibliotecas como `mcstatus` ou `python-minecraft-protocol` podem ajudar. Considere usar uma implementação de servidor Minecraft pré-construída (como um plugin Spigot modificado ou um servidor personalizado baseado em uma biblioteca) para uma solução mais robusta. * **Manipulação de Comandos:** A função `process_message` é o núcleo do processamento de comandos. Ela analisa os comandos e chama as funções apropriadas. Você precisará expandir isso para lidar com mais comandos e lógica. * **Integração com o Claude:** A função `get_weather_from_claude` faz uma chamada de API para o Claude-3.7-sonnet. **Importante:** * **Chave API:** Substitua `"SUA_CHAVE_API_CLAUDE"` pela sua chave API Claude real. * **Endpoint:** Verifique o endpoint da API Claude correto. * **Nome do Modelo:** Use o nome do modelo correto (por exemplo, `"claude-3.5-sonnet-20240620"`). Os nomes dos modelos podem mudar. * **Tratamento de Erros:** O código inclui tratamento de erros básico para solicitações de API e análise de respostas. Melhore isso para uso em produção. * **Limitação de Taxa:** Esteja ciente dos limites de taxa da API do Claude e implemente o tratamento apropriado para evitar excedê-los. * **Engenharia de Prompt:** O prompt enviado para o Claude ("Qual é o clima atual em {location}? Dê um breve resumo.") é crucial. Experimente diferentes prompts para obter os melhores resultados. * **Análise de Resposta:** O código assume um formato específico para a resposta do Claude. Você precisará ajustar a linha `weather_summary = json_response['content'][0]['text']` para corresponder ao formato de resposta real. Use `print(json_response)` para inspecionar a resposta. * **Integração com o Cursor:** Este é um espaço reservado. Você precisará decidir como o Cursor se comunicará com o servidor. Possíveis opções: * **Endpoint HTTP:** Crie um endpoint HTTP simples (usando Flask ou FastAPI) para que o Cursor possa enviar comandos. O servidor então processaria esses comandos e enviaria respostas de volta para o cliente Minecraft. * **WebSockets:** Use WebSockets para comunicação em tempo real entre o Cursor e o servidor. * **Fila de Mensagens (por exemplo, RabbitMQ, Redis Pub/Sub):** Use uma fila de mensagens para comunicação assíncrona. * **Threading:** O servidor usa threads para lidar com várias conexões de clientes simultaneamente. * **Segurança:** Este é um exemplo muito básico e carece de medidas de segurança. Para um servidor de produção, você precisará implementar autenticação, autorização e validação de entrada adequadas para evitar vulnerabilidades de segurança. * **Tratamento de Erros:** O tratamento de erros é básico. Melhore-o para fornecer mensagens de erro mais informativas e lidar com diferentes tipos de erros de forma elegante. * **Implementação do Protocolo Minecraft:** Como mencionado antes, este é o maior desafio. Você provavelmente precisará usar uma biblioteca ou framework para lidar com o protocolo Minecraft corretamente. * **Operações Assíncronas:** Considere usar programação assíncrona (por exemplo, `asyncio` em Python) para melhor desempenho, especialmente ao fazer chamadas de API para o Claude. **Como Integrar com o Cursor:** 1. **Escolha um Método de Comunicação:** Decida como o Cursor enviará comandos para o servidor (HTTP, WebSockets, fila de mensagens). 2. **Implemente a API:** Crie o endpoint de API ou mecanismo necessário no servidor para receber comandos do Cursor. 3. **Envie Comandos do Cursor:** Configure o Cursor para enviar comandos para a API do servidor. Isso pode envolver a escrita de uma extensão do Cursor ou o uso dos recursos de script integrados do Cursor. 4. **Processe Comandos:** Na função `process_message`, lide com os comandos recebidos do Cursor. 5. **Envie Respostas:** Envie respostas de volta para o cliente Minecraft (ou para o Cursor, dependendo do método de comunicação). **Exemplo de Integração com o Cursor (Endpoint HTTP usando Flask):** ```python # (Adicione ao arquivo mcp_server.py) from flask import Flask, request app = Flask(__name__) @app.route('/cursor_command', methods=['POST']) def cursor_command(): data = request.get_json() command = data.get('command') if command: response = process_message(f"/cursor {command}") # Simula um comando /cursor return response, 200 else: return "Nenhum comando fornecido", 400 # Modifique a função start_server para executar o aplicativo Flask em uma thread separada def start_server(): server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server_socket.bind((HOST, PORT)) server_socket.listen() print(f"Servidor ouvindo em {HOST}:{PORT}") # Inicie o aplicativo Flask em uma thread separada flask_thread = threading.Thread(target=app.run, kwargs={'host': '0.0.0.0', 'port': 5000, 'debug': False, 'use_reloader': False}) # Escolha uma porta diferente para o Flask flask_thread.daemon = True # Permite que a thread principal saia mesmo se a thread Flask estiver em execução flask_thread.start() try: while True: conn, addr = server_socket.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.start() except KeyboardInterrupt: print("Servidor desligando.") finally: server_socket.close() if __name__ == "__main__": start_server() ``` **No Cursor:** Você então usaria uma ferramenta como `curl` ou `requests` (dentro de uma extensão ou script do Cursor) para enviar uma solicitação POST para `http://localhost:5000/cursor_command` com um payload JSON como: ```json { "command": "faça algo" } ``` **Notas Importantes:** * Este é um exemplo muito simplificado. Construir um servidor MCP completo com integração de IA é um projeto significativo. * Concentre-se em implementar o protocolo Minecraft corretamente primeiro. * Comece com um comando simples (como recuperação de clima) e adicione gradualmente mais recursos. * Teste minuciosamente seu código e lide com erros de forma elegante. * Considere usar um framework ou biblioteca mais robusto para construir o servidor. * Preste muita atenção às práticas recomendadas de segurança. Este modelo detalhado fornece uma base sólida para construir seu servidor MCP com integração Cursor e Claude. Lembre-se de adaptá-lo às suas necessidades e requisitos específicos. Boa sorte!

Model Context Protocol (MCP) Types

Servidor de Protocolo de Contexto de Modelo (MCP) para Rust

GitHub Kanban MCP Server

Mirror of

dap-mcp

Uma implementação do Protocolo de Contexto do Modelo (MCP) que permite a interação com adaptadores de depuração, permitindo que modelos de linguagem controlem depuradores, definam pontos de interrupção, avaliem expressões e naveguem pelo código-fonte durante sessões de depuração.