Discover Awesome MCP Servers

WolframAlpha LLM MCP Server

Permite consultar a API LLM do WolframAlpha para perguntas em linguagem natural, fornecendo respostas estruturadas e simplificadas, otimizadas para o consumo por LLMs.

MCP Blockchain Server

Um sistema seguro que permite que assistentes de IA interajam com dados de blockchain e preparem transações, garantindo que os usuários mantenham controle exclusivo sobre suas chaves privadas e assinatura de transações.

X MCP Server

Servidor para integração com o X (Twitter) que oferece ferramentas para ler sua timeline e interagir com tweets. Projetado para uso com o Claude desktop.

GitLab MCP Server

Uma implementação de servidor personalizada que permite que assistentes de IA interajam com repositórios GitLab, fornecendo capacidades para pesquisar, buscar arquivos, criar/atualizar conteúdo e gerenciar issues e merge requests.

MCP Server for Replicate

Uma implementação de servidor FastMCP que fornece uma interface padronizada para acessar modelos de IA hospedados na API da Replicate, atualmente suportando geração de imagens com parâmetros personalizáveis.

MCP Security Audit Server

Audita as dependências de pacotes npm em busca de vulnerabilidades de segurança, fornecendo relatórios detalhados e recomendações de correção com integração MCP.

MCP Intercom Server

Fornece acesso a conversas e chats do Intercom através do Protocolo de Contexto do Modelo, permitindo que LLMs consultem e analisem conversas do Intercom com várias opções de filtragem.

BioMCP

Um servidor de Protocolo de Contexto de Modelo que aprimora modelos de linguagem com capacidades de análise de estrutura de proteínas, permitindo análises detalhadas de sítios ativos e buscas de proteínas relacionadas a doenças através de bancos de dados de proteínas estabelecidos.

Seq MCP Server

O Seq MCP Server permite a interação com os endpoints da API do Seq para registro e monitoramento, fornecendo ferramentas para gerenciar sinais, eventos e alertas com extensas opções de filtragem e configuração.

Barnsworthburning MCP

Um servidor de Protocolo de Contexto de Modelo que permite pesquisar conteúdo de barnsworthburning.net diretamente através de clientes de IA compatíveis, como o Claude para Desktop.

Code Research MCP Server

Facilita a busca e o acesso a recursos de programação em plataformas como Stack Overflow, MDN, GitHub, npm e PyPI, auxiliando LLMs a encontrar exemplos de código e documentação.

Jenkins Server MCP

A Model Context Protocol server that enables AI assistants to interact with Jenkins CI/CD servers, providing tools to check build statuses, trigger builds, and retrieve build logs.

mcp-omnisearch

🔍 Um servidor de Protocolo de Contexto de Modelo (MCP) que fornece acesso unificado a múltiplos mecanismos de busca (Tavily, Brave, Kagi), ferramentas de IA (Perplexity, FastGPT) e serviços de processamento de conteúdo (Jina AI, Kagi). Combina busca, respostas de IA, processamento de conteúdo e recursos de aprimoramento através de uma única interface.

Redmine MCP Server

Um servidor de Protocolo de Contexto de Modelo para interagir com o Redmine usando sua API REST, permitindo o gerenciamento de tickets, projetos e dados de usuário através da integração com LLMs.

MCP Server Template for Cursor IDE

Absolutely! Here's a template and guide for creating custom Cursor IDE tools using the Model Context Protocol (MCP), with instructions for deploying your MCP server to Heroku and connecting it to Cursor: **Template Structure** ```python # main.py (Your MCP Server) import os import json from typing import Dict, Any, List from fastapi import FastAPI, Request, HTTPException from fastapi.middleware.cors import CORSMiddleware import uvicorn # --- Configuration --- PORT = int(os.environ.get("PORT", 8000)) # Heroku uses PORT env var MODEL_NAME = "MyCustomTool" # Unique name for your tool DESCRIPTION = "A custom tool for Cursor IDE." ENDPOINT = "/my_tool" # Endpoint for Cursor to send requests # --- FastAPI Setup --- app = FastAPI(title=MODEL_NAME, description=DESCRIPTION) # CORS (Important for web-based IDEs like Cursor) app.add_middleware( CORSMiddleware, allow_origins=["*"], # Adjust for production! allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) # --- MCP Endpoints --- @app.post(ENDPOINT + "/info") async def get_info() -> Dict[str, Any]: """Returns information about the tool.""" return { "model_name": MODEL_NAME, "description": DESCRIPTION, "stream": False, # Set to True if your tool supports streaming } @app.post(ENDPOINT + "/generate") async def generate(request: Request) -> Dict[str, Any]: """Handles generation requests from Cursor.""" try: data = await request.json() prompt = data.get("prompt", "") context = data.get("context", {}) # Context from Cursor # --- Your Tool Logic Here --- # Process the prompt and context to generate a response. # Example: response_text = f"You asked: {prompt}\nContext: {context}" return {"response": response_text} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) # --- Main Execution --- if __name__ == "__main__": uvicorn.run(app, host="0.0.0.0", port=PORT) ``` **Explanation** 1. **Imports:** Essential libraries for FastAPI, JSON handling, and environment variables. 2. **Configuration:** * `PORT`: Gets the port from the environment (Heroku sets this). Defaults to 8000 for local testing. * `MODEL_NAME`: A unique name for your tool. This is how Cursor identifies it. * `DESCRIPTION`: A brief description of your tool. * `ENDPOINT`: The URL path where Cursor will send requests. Make sure this is unique. 3. **FastAPI Setup:** * Creates a FastAPI app. * **CORS:** Crucially important! Cursor runs in a web browser, so you need to enable CORS to allow requests from Cursor's origin. In production, replace `"*"` with the specific origin of your Cursor instance. 4. **MCP Endpoints:** * `/info`: Returns metadata about your tool. `stream` indicates whether your tool supports streaming responses (more advanced). * `/generate`: The main endpoint for handling generation requests. * It extracts the `prompt` and `context` from the request body. * **Your Tool Logic:** This is where you implement the core functionality of your tool. Process the prompt and context to generate a response. * Returns a JSON response with the `response` field containing the generated text. 5. **Main Execution:** Starts the FastAPI server using Uvicorn. **Steps to Deploy to Heroku** 1. **Create a Heroku Account:** If you don't have one, sign up at [https://www.heroku.com/](https://www.heroku.com/). 2. **Install the Heroku CLI:** Follow the instructions on the Heroku website to install the Heroku Command Line Interface (CLI). 3. **Create a Heroku App:** ```bash heroku create my-cursor-tool # Replace with your desired app name ``` 4. **Create a `requirements.txt` File:** List all the Python dependencies your project needs: ``` fastapi uvicorn[standard] python-multipart # Required for form data (if needed) ``` 5. **Create a `Procfile`:** This tells Heroku how to run your app. Create a file named `Procfile` (no extension) with the following content: ``` web: uvicorn main:app --host=0.0.0.0 --port=$PORT ``` 6. **Deploy to Heroku:** ```bash git init git add . git commit -m "Initial commit" heroku git:remote -a my-cursor-tool # Replace with your app name git push heroku main ``` 7. **Check Logs:** After deployment, check the Heroku logs to ensure everything is running correctly: ```bash heroku logs --tail ``` **Connecting to Cursor IDE** 1. **Get Your Heroku App URL:** After deployment, Heroku will provide a URL for your app (e.g., `https://my-cursor-tool.herokuapp.com`). 2. **Configure Cursor:** * Open Cursor IDE. * Go to Settings (usually Cmd + , or Ctrl + ,). * Find the "Model Context Protocol" section. * Click "Add Model". * Enter the following: * **Model Name:** The `MODEL_NAME` you defined in your code (e.g., `MyCustomTool`). * **Endpoint:** The full URL of your Heroku app, including the endpoint path (e.g., `https://my-cursor-tool.herokuapp.com/my_tool`). 3. **Test Your Tool:** In Cursor, try using your custom tool. You should be able to access it through the command palette or other Cursor features that support MCP. **Important Considerations** * **Security:** In a production environment, you should implement proper authentication and authorization to protect your MCP server. Consider using API keys or other security measures. * **Error Handling:** Implement robust error handling in your tool logic to gracefully handle unexpected situations. * **Rate Limiting:** If your tool is resource-intensive, consider implementing rate limiting to prevent abuse. * **Context:** Pay close attention to the `context` data that Cursor sends. This can provide valuable information about the current code, file, or project. * **Streaming:** If you want to support streaming responses, you'll need to modify your code to use Server-Sent Events (SSE) or WebSockets. * **Heroku Free Tier:** Be aware that the Heroku free tier has limitations. Your app may sleep if it's not used for a while. Consider upgrading to a paid plan for production use. * **Environment Variables:** Use environment variables for sensitive information like API keys or database credentials. You can set environment variables in the Heroku dashboard. **Example Tool Logic** Here's a more concrete example of tool logic that uses the context to provide code suggestions: ```python @app.post(ENDPOINT + "/generate") async def generate(request: Request) -> Dict[str, Any]: try: data = await request.json() prompt = data.get("prompt", "") context = data.get("context", {}) current_file = context.get("currentFile", {}) file_content = current_file.get("content", "") cursor_position = context.get("cursorPosition", {}) line = cursor_position.get("line", 0) character = cursor_position.get("character", 0) # Example: Suggest a function name based on the current line if "def " in file_content.splitlines()[line]: response_text = "Perhaps you should name this function 'process_data'?" else: response_text = "I'm ready to help with your coding!" return {"response": response_text} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) ``` **Translation to Portuguese** Here's a translation of the key parts of the explanation: **Tradução para Português** **Estrutura do Modelo** (A estrutura do código em Python permanece a mesma) **Explicação** 1. **Importações:** Bibliotecas essenciais para FastAPI, manipulação de JSON e variáveis de ambiente. 2. **Configuração:** * `PORT`: Obtém a porta do ambiente (Heroku define isso). O padrão é 8000 para testes locais. * `MODEL_NAME`: Um nome único para sua ferramenta. É assim que o Cursor a identifica. * `DESCRIPTION`: Uma breve descrição da sua ferramenta. * `ENDPOINT`: O caminho da URL onde o Cursor enviará as solicitações. Certifique-se de que seja único. 3. **Configuração do FastAPI:** * Cria um aplicativo FastAPI. * **CORS:** Crucialmente importante! O Cursor é executado em um navegador da web, então você precisa habilitar o CORS para permitir solicitações da origem do Cursor. Em produção, substitua `"*"` pela origem específica da sua instância do Cursor. 4. **Endpoints MCP:** * `/info`: Retorna metadados sobre sua ferramenta. `stream` indica se sua ferramenta suporta respostas de streaming (mais avançado). * `/generate`: O endpoint principal para lidar com solicitações de geração. * Ele extrai o `prompt` e o `context` do corpo da solicitação. * **Lógica da sua Ferramenta:** É aqui que você implementa a funcionalidade principal da sua ferramenta. Processe o prompt e o contexto para gerar uma resposta. * Retorna uma resposta JSON com o campo `response` contendo o texto gerado. 5. **Execução Principal:** Inicia o servidor FastAPI usando Uvicorn. **Passos para Implantar no Heroku** 1. **Crie uma Conta Heroku:** Se você não tiver uma, inscreva-se em [https://www.heroku.com/](https://www.heroku.com/). 2. **Instale o Heroku CLI:** Siga as instruções no site do Heroku para instalar a Interface de Linha de Comando (CLI) do Heroku. 3. **Crie um Aplicativo Heroku:** ```bash heroku create my-cursor-tool # Substitua pelo nome desejado do seu aplicativo ``` 4. **Crie um Arquivo `requirements.txt`:** Liste todas as dependências Python que seu projeto precisa: ``` fastapi uvicorn[standard] python-multipart # Necessário para dados de formulário (se necessário) ``` 5. **Crie um `Procfile`:** Isso diz ao Heroku como executar seu aplicativo. Crie um arquivo chamado `Procfile` (sem extensão) com o seguinte conteúdo: ``` web: uvicorn main:app --host=0.0.0.0 --port=$PORT ``` 6. **Implante no Heroku:** ```bash git init git add . git commit -m "Commit inicial" heroku git:remote -a my-cursor-tool # Substitua pelo nome do seu aplicativo git push heroku main ``` 7. **Verifique os Logs:** Após a implantação, verifique os logs do Heroku para garantir que tudo esteja funcionando corretamente: ```bash heroku logs --tail ``` **Conectando ao Cursor IDE** 1. **Obtenha o URL do seu Aplicativo Heroku:** Após a implantação, o Heroku fornecerá um URL para seu aplicativo (por exemplo, `https://my-cursor-tool.herokuapp.com`). 2. **Configure o Cursor:** * Abra o Cursor IDE. * Vá para Configurações (geralmente Cmd + , ou Ctrl + ,). * Encontre a seção "Model Context Protocol". * Clique em "Add Model". * Insira o seguinte: * **Model Name:** O `MODEL_NAME` que você definiu em seu código (por exemplo, `MyCustomTool`). * **Endpoint:** O URL completo do seu aplicativo Heroku, incluindo o caminho do endpoint (por exemplo, `https://my-cursor-tool.herokuapp.com/my_tool`). 3. **Teste sua Ferramenta:** No Cursor, tente usar sua ferramenta personalizada. Você deve conseguir acessá-la através da paleta de comandos ou outros recursos do Cursor que suportam MCP. **Considerações Importantes** * **Segurança:** Em um ambiente de produção, você deve implementar autenticação e autorização adequadas para proteger seu servidor MCP. Considere usar chaves de API ou outras medidas de segurança. * **Tratamento de Erros:** Implemente um tratamento de erros robusto na lógica da sua ferramenta para lidar normalmente com situações inesperadas. * **Limitação de Taxa:** Se sua ferramenta for intensiva em recursos, considere implementar a limitação de taxa para evitar abusos. * **Contexto:** Preste muita atenção aos dados de `context` que o Cursor envia. Isso pode fornecer informações valiosas sobre o código, arquivo ou projeto atual. * **Streaming:** Se você deseja suportar respostas de streaming, você precisará modificar seu código para usar Server-Sent Events (SSE) ou WebSockets. * **Nível Gratuito do Heroku:** Esteja ciente de que o nível gratuito do Heroku tem limitações. Seu aplicativo pode dormir se não for usado por um tempo. Considere atualizar para um plano pago para uso em produção. * **Variáveis de Ambiente:** Use variáveis de ambiente para informações confidenciais, como chaves de API ou credenciais de banco de dados. Você pode definir variáveis de ambiente no painel do Heroku. I hope this comprehensive template and guide helps you create amazing custom tools for Cursor IDE! Let me know if you have any other questions.

API Tester MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que Claude faça requisições de API em seu nome, fornecendo ferramentas para testar várias APIs, incluindo requisições HTTP e integrações com a OpenAI, sem compartilhar suas chaves de API no chat.

Better Auth MCP Server

Permite o gerenciamento de autenticação de nível empresarial com tratamento seguro de credenciais e suporte para autenticação multi-protocolo, completo com ferramentas para analisar, configurar e testar sistemas de autenticação.

Morpho API MCP Server

Enables interaction with the Morpho GraphQL API, providing tools for accessing market data, vaults, positions, and transactions through a Model Context Protocol (MCP) server.

MCP Salesforce Connector

Um servidor de Protocolo de Contexto de Modelo que permite que LLMs interajam com dados do Salesforce por meio de consultas SOQL, pesquisas SOSL e várias operações de API, incluindo gerenciamento de registros.

video-editing-mcp

Carregue, edite e gere vídeos a partir do LLM favorito de todos e da Selva de Vídeos.

MCP Node Fetch

Um servidor MCP que permite buscar conteúdo da web usando a biblioteca undici do Node.js, suportando vários métodos HTTP, formatos de conteúdo e configurações de requisição.

Dify MCP Server

Integra a API Dify AI para fornecer geração de código para componentes Ant Design, suportando entradas de texto e imagem com capacidades de processamento de fluxo.

Higress AI-Search MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que modelos de IA realizem buscas em tempo real na internet e em bases de conhecimento através do Higress, aprimorando as respostas do modelo com informações atualizadas do Google, Bing, Arxiv e bases de conhecimento internas.

Solana MCP Server

Um servidor que fornece endpoints RPC simples para operações comuns do blockchain Solana, permitindo que os usuários verifiquem saldos, obtenham informações da conta e transfiram SOL entre contas.

Govee MCP Server

Permite que os usuários controlem dispositivos LED Govee usando a API Govee, com funcionalidades para ligar/desligar dispositivos, definir cores e ajustar o brilho através de uma CLI ou clientes MCP.

MCP Local Web Search Server

Permite realizar pesquisas na web localmente e extrair conteúdo estruturado de páginas da web usando o Protocolo de Contexto do Modelo, com limites de resultados personalizáveis e filtragem de domínio.

Huntress-MCP-Server

Servidor MCP para integração com a API Huntress

MCP-Server-IETF

Um servidor de Protocolo de Contexto de Modelo que permite que Grandes Modelos de Linguagem pesquisem e acessem documentos RFC da IETF com suporte à paginação.

dbSNP MCP Plugin

An MCP plugin that provides access to NCBI's dbSNP database, allowing developers to retrieve genetic variant information, search for SNPs, and access clinical significance data directly in their development environment.

Docker MCP Server

Um servidor MCP que permite gerenciar contêineres Docker através de linguagem natural, possibilitando aos usuários compor, inspecionar e depurar contêineres sem executar comandos diretamente.