Discover Awesome MCP Servers

MCP File Context Server

Um servidor de Protocolo de Contexto de Modelo que permite que LLMs leiam, pesquisem e analisem arquivos de código com recursos avançados de cache e monitoramento de arquivos em tempo real.

Gmail MCP

Um servidor que permite que o Claude pesquise e recupere e-mails da sua conta do Gmail, suportando funções como pesquisar e-mails, recuperar o conteúdo completo de e-mails específicos e listar mensagens recentes.

MCP Playwright CDP

Permite que LLMs realizem automação de navegador através do framework Playwright com suporte ao Protocolo Chrome DevTools, conectando-se a instâncias Chrome existentes para interações web avançadas e execução de JavaScript.

Laravel Helpers MCP

Uma coleção de ferramentas auxiliares do Laravel para integração com o Cursor IDE, fornecendo recursos como visualização de logs, pesquisa de erros, execução de comandos Artisan e exibição de informações do modelo diretamente no editor.

Claude Server MCP

Oferece gerenciamento de contexto sofisticado para o Claude, permitindo contexto persistente entre sessões, organização específica do projeto e continuidade da conversa.

CodeSavant

Oferece capacidades de manipulação, execução e controle de versão de código. Permite que assistentes de IA leiam, escrevam e executem código, mantendo um histórico de alterações.

MCP Server

O Servidor MCP integra APIs do Youtube-Summarizer como ferramentas dentro do protocolo MCP, permitindo a interação local de aplicações de IA e a utilização de ferramentas através de consultas em linguagem natural.

MCP Postgres Server

Um servidor que implementa o Protocolo de Contexto de Modelo (MCP) para o Cursor, permitindo o uso de um banco de dados PostgreSQL como armazenamento para contextos de modelo, possibilitando a exploração e consulta segura do banco de dados.

MCP File Preview Server

Fornece capacidades de visualização e análise de arquivos HTML. Este servidor permite capturar screenshots de página inteira de arquivos HTML locais e analisar sua estrutura.

Explorium AgentSource MCP Server

O Explorium AgentSource MCP Server capacita cada agente a se tornar um agente especializado em Go-To-Market, impulsionado por IA! Com mais de 20 endpoints especializados, projetados para prospecção, vendas e geração de leads, os agentes podem gerar e enriquecer contas e prospects sem esforço, acessar insights de negócios profundos, e...

MCP EVM Signer

Um servidor que gerencia chaves privadas Ethereum de forma segura localmente e permite que o Claude para Desktop interaja com blockchains compatíveis com EVM através da Infura.

claude-code-mcp

Este projeto tem como objetivo construir um servidor Claude Code MCP e implementar suas ferramentas associadas (explain\_code, review\_code, fix\_code, edit\_code, test\_code, simulate\_command, sua\_própria\_consulta). O servidor é implementado usando Node.js e o SDK MCP. Ele recebe solicitações de ferramentas de clientes via Stdio, dinamicamente.

Super Windows CLI MCP Server

Um servidor MCP de CLI do Windows aprimorado, que oferece capacidades de acesso irrestrito ao sistema, projetado para ambientes confiáveis com requisitos de acesso total ao sistema.

Notion MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que Claude e outros LLMs interajam com espaços de trabalho do Notion, fornecendo capacidades como pesquisar, recuperar, criar e atualizar páginas, bem como gerenciar bancos de dados.

Cline Personas MCP Server

Um servidor MCP para gerenciar e ativar templates e componentes de persona, escrevendo em arquivos .clinerules, com suporte para rastreamento de versão e armazenamento baseado em arquivos.

Face Generator MCP Server

Gera imagens realistas de rostos humanos que não representam pessoas reais, oferecendo vários formatos de saída, dimensões configuráveis e capacidades de geração em lote.

Code Sandbox MCP

Um servidor MCP para criar um ambiente de sandbox de código seguro para executar código dentro de contêineres Docker.

Github-Oauth MCP Server

Facilita a autenticação com o GitHub usando o protocolo OAuth, permitindo acesso e interação seguros com repositórios e serviços do GitHub.

Azure OpenAI

Aqui está uma implementação mínima de uma aplicação servidor/cliente utilizando o Protocolo de Contexto de Modelo (MCP) e o Azure OpenAI: **Observação:** Este é um exemplo simplificado e requer a instalação das bibliotecas necessárias (como `openai`, `fastapi`, `uvicorn`, etc.) e a configuração correta das suas credenciais do Azure OpenAI. **1. Servidor (usando FastAPI):** ```python from fastapi import FastAPI, Request, HTTPException from pydantic import BaseModel import openai import os app = FastAPI() # Configurar as credenciais do Azure OpenAI openai.api_type = "azure" openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") # Obtenha do seu ambiente openai.api_version = "2023-05-15" # Use a versão da API apropriada openai.api_key = os.getenv("AZURE_OPENAI_KEY") # Obtenha do seu ambiente deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME") # Obtenha do seu ambiente class Message(BaseModel): content: str role: str # "user" ou "system" class ChatRequest(BaseModel): messages: list[Message] @app.post("/chat") async def chat_endpoint(request: ChatRequest): try: response = openai.ChatCompletion.create( engine=deployment_name, messages=[message.dict() for message in request.messages], temperature=0.7, max_tokens=800, n=1, stop=None, ) return {"response": response.choices[0].message.content} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` **Explicação do Servidor:** * **Importações:** Importa as bibliotecas necessárias do FastAPI, Pydantic e OpenAI. * **Configuração do Azure OpenAI:** Configura as credenciais do Azure OpenAI usando variáveis de ambiente. **IMPORTANTE:** Nunca coloque suas chaves diretamente no código. Use variáveis de ambiente ou um sistema de gerenciamento de segredos. * **Modelos de Dados (Pydantic):** Define modelos de dados para a requisição (`ChatRequest`) e as mensagens (`Message`) usando Pydantic para validação e tipagem. * **Endpoint `/chat`:** * Recebe uma requisição POST com uma lista de mensagens (`ChatRequest`). * Converte as mensagens Pydantic para dicionários para serem usadas pela API OpenAI. * Chama a API `openai.ChatCompletion.create` com as mensagens, configurando parâmetros como `temperature`, `max_tokens`, etc. * Retorna a resposta do modelo OpenAI. * Trata erros e retorna um código de status 500 em caso de falha. * **Execução:** Inicia o servidor FastAPI usando `uvicorn`. **2. Cliente (exemplo simples):** ```python import requests import json # URL do servidor SERVER_URL = "http://localhost:8000/chat" # Mensagens de exemplo messages = [ {"role": "system", "content": "Você é um assistente útil."}, {"role": "user", "content": "Qual é a capital da França?"} ] # Criar o payload da requisição payload = {"messages": messages} # Enviar a requisição POST try: response = requests.post(SERVER_URL, data=json.dumps(payload)) response.raise_for_status() # Levanta uma exceção para códigos de erro HTTP data = response.json() print("Resposta do servidor:", data["response"]) except requests.exceptions.RequestException as e: print("Erro na requisição:", e) except json.JSONDecodeError as e: print("Erro ao decodificar a resposta JSON:", e) ``` **Explicação do Cliente:** * **Importações:** Importa as bibliotecas `requests` e `json`. * **URL do Servidor:** Define o URL do servidor FastAPI. * **Mensagens de Exemplo:** Cria uma lista de mensagens de exemplo para enviar ao servidor. * **Payload da Requisição:** Cria um dicionário contendo a lista de mensagens. * **Enviar Requisição POST:** * Envia uma requisição POST para o endpoint `/chat` do servidor. * Converte o payload para JSON usando `json.dumps`. * Trata erros de requisição e erros de decodificação JSON. * Imprime a resposta do servidor. **Como Executar:** 1. **Instale as dependências:** ```bash pip install fastapi uvicorn openai python-dotenv requests ``` 2. **Configure as variáveis de ambiente:** * Crie um arquivo `.env` na mesma pasta dos seus scripts. * Adicione as seguintes linhas, substituindo pelos seus valores reais: ``` AZURE_OPENAI_ENDPOINT="YOUR_AZURE_OPENAI_ENDPOINT" AZURE_OPENAI_KEY="YOUR_AZURE_OPENAI_KEY" AZURE_OPENAI_DEPLOYMENT_NAME="YOUR_AZURE_OPENAI_DEPLOYMENT_NAME" ``` * No seu código Python, você pode usar `os.getenv()` para acessar essas variáveis. Se você não quiser usar um arquivo `.env`, você pode definir as variáveis de ambiente diretamente no seu sistema operacional. 3. **Execute o servidor:** ```bash python seu_servidor.py # Substitua seu_servidor.py pelo nome do seu arquivo ``` 4. **Execute o cliente:** ```bash python seu_cliente.py # Substitua seu_cliente.py pelo nome do seu arquivo ``` **Considerações sobre o MCP (Model Context Protocol):** Este exemplo, embora funcional, não implementa o MCP de forma completa. O MCP é um protocolo mais complexo que envolve: * **Gerenciamento de Contexto:** O servidor deve ser capaz de manter o contexto da conversa entre múltiplas requisições. Isso geralmente envolve o uso de um banco de dados ou cache para armazenar o histórico da conversa. * **Tokenização e Limites de Contexto:** O servidor deve ser capaz de tokenizar as mensagens e garantir que o tamanho total do contexto (em tokens) não exceda o limite do modelo OpenAI. Se o limite for excedido, o servidor deve remover as mensagens mais antigas do contexto. * **ID de Sessão:** O cliente deve enviar um ID de sessão para o servidor para que o servidor possa identificar a conversa correta. Para implementar o MCP de forma completa, você precisaria adicionar lógica para: * Gerenciar o contexto da conversa (armazenando o histórico das mensagens). * Tokenizar as mensagens (usando uma biblioteca como `tiktoken`). * Remover mensagens antigas do contexto quando o limite de tokens for atingido. * Implementar um sistema de ID de sessão. **Exemplo de como adicionar um ID de sessão (simplificado):** **Servidor (modificado):** ```python from fastapi import FastAPI, Request, HTTPException from pydantic import BaseModel import openai import os import uuid app = FastAPI() # Configurar as credenciais do Azure OpenAI openai.api_type = "azure" openai.api_base = os.getenv("AZURE_OPENAI_ENDPOINT") openai.api_version = "2023-05-15" openai.api_key = os.getenv("AZURE_OPENAI_KEY") deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME") class Message(BaseModel): content: str role: str class ChatRequest(BaseModel): messages: list[Message] session_id: str # Adicionado o ID da sessão # Dicionário para armazenar o contexto da conversa (substitua por um banco de dados em produção) conversation_context = {} @app.post("/chat") async def chat_endpoint(request: ChatRequest): session_id = request.session_id messages = request.messages # Obter o contexto da conversa existente ou criar um novo if session_id in conversation_context: context = conversation_context[session_id] else: context = [] # Adicionar as novas mensagens ao contexto context.extend([message.dict() for message in messages]) try: response = openai.ChatCompletion.create( engine=deployment_name, messages=context, # Usar o contexto completo temperature=0.7, max_tokens=800, n=1, stop=None, ) response_content = response.choices[0].message.content # Adicionar a resposta do modelo ao contexto context.append({"role": "assistant", "content": response_content}) # Atualizar o contexto da conversa conversation_context[session_id] = context return {"response": response_content, "session_id": session_id} except Exception as e: raise HTTPException(status_code=500, detail=str(e)) @app.get("/new_session") async def new_session_endpoint(): session_id = str(uuid.uuid4()) return {"session_id": session_id} if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000) ``` **Cliente (modificado):** ```python import requests import json SERVER_URL = "http://localhost:8000/chat" NEW_SESSION_URL = "http://localhost:8000/new_session" # Obter um novo ID de sessão try: session_response = requests.get(NEW_SESSION_URL) session_response.raise_for_status() session_data = session_response.json() session_id = session_data["session_id"] print("Novo ID de sessão:", session_id) except requests.exceptions.RequestException as e: print("Erro ao obter o ID de sessão:", e) exit() # Mensagens de exemplo messages = [ {"role": "user", "content": "Qual é a capital da França?"} ] # Criar o payload da requisição payload = {"messages": messages, "session_id": session_id} # Adicionar o ID da sessão # Enviar a requisição POST try: response = requests.post(SERVER_URL, data=json.dumps(payload)) response.raise_for_status() data = response.json() print("Resposta do servidor:", data["response"]) print("ID de sessão retornado:", data["session_id"]) except requests.exceptions.RequestException as e: print("Erro na requisição:", e) except json.JSONDecodeError as e: print("Erro ao decodificar a resposta JSON:", e) # Enviar outra mensagem na mesma sessão messages2 = [ {"role": "user", "content": "E qual é a população?"} ] payload2 = {"messages": messages2, "session_id": session_id} try: response2 = requests.post(SERVER_URL, data=json.dumps(payload2)) response2.raise_for_status() data2 = response2.json() print("Resposta do servidor (segunda mensagem):", data2["response"]) print("ID de sessão retornado (segunda mensagem):", data2["session_id"]) except requests.exceptions.RequestException as e: print("Erro na requisição (segunda mensagem):", e) except json.JSONDecodeError as e: print("Erro ao decodificar a resposta JSON (segunda mensagem):", e) ``` **Mudanças:** * **Servidor:** * Adicionado um campo `session_id` ao `ChatRequest`. * Adicionado um dicionário `conversation_context` para armazenar o histórico da conversa (substitua por um banco de dados em produção). * O endpoint `/chat` agora recebe o `session_id` e usa o contexto da conversa existente (se houver). * A resposta do modelo é adicionada ao contexto da conversa. * Adicionado um endpoint `/new_session` para gerar um novo ID de sessão. * **Cliente:** * Obtém um novo ID de sessão do endpoint `/new_session`. * Envia o `session_id` em cada requisição. * Envia uma segunda mensagem usando o mesmo `session_id` para continuar a conversa. **Observações:** * Este exemplo ainda é simplificado e não implementa tokenização ou limites de contexto. * Em um ambiente de produção, você deve usar um banco de dados para armazenar o contexto da conversa em vez de um dicionário na memória. * Você deve implementar tratamento de erros mais robusto. * Considere usar um sistema de autenticação e autorização para proteger seu servidor. Este exemplo fornece um ponto de partida para construir uma aplicação servidor/cliente mais completa que utiliza o MCP e o Azure OpenAI. Lembre-se de adaptar o código às suas necessidades específicas e de seguir as melhores práticas de segurança.

mcp-local-dev

Crie ambientes de desenvolvimento locais isolados diretamente do Github e execute testes, veja a cobertura e muito mais! Suporta Python, Node, Bun e muitos executores de teste.

MCP-LOGO-GEN

Servidor de Ferramentas MCP para Geração de Logotipos. Este servidor oferece recursos de geração de logotipos usando FAL AI, com ferramentas para geração de imagens, remoção de fundo e redimensionamento de imagens.

mcp-k8s-go

Este projeto tem como objetivo ser tanto um servidor MCP conectando-se ao Kubernetes quanto uma biblioteca para construir mais servidores para quaisquer recursos personalizados no Kubernetes.

MCP-AnkiConnect

Um servidor MCP que integra o Claude com flashcards Anki, permitindo que os usuários revisem os cartões pendentes e criem novos flashcards diretamente através da conversa.

Google Tasks MCP Server

Integra-se com o Google Tasks para permitir listar, ler, pesquisar, criar, atualizar e excluir tarefas.

MCP Terminal Server

Um servidor de execução de terminal seguro que permite a execução controlada de comandos com recursos de segurança e limites de recursos através do Protocolo de Contexto de Modelo (MCP).

MCP Tasks Organizer

Um servidor MCP que converte planos do agente Cursor em listas de tarefas markdown estruturadas e as organiza no seu repositório, ajudando você a rastrear planos e recomendações gerados por IA como especificações acionáveis.

Model Context Protocol Server for Solana Client

Um servidor que permite a interação com a blockchain Solana, fornecendo acesso a mais de 40 métodos RPC da Solana, incluindo a obtenção de saldos, detalhes de transações, informações de blocos e o envio de transações.

MCP-JIRA-Python Server

Um servidor baseado em Python que permite a integração perfeita com o JIRA para gerenciar e interagir com projetos através de APIs personalizadas.

Obsidian MCP REST Server

Fornece uma interface padronizada para que assistentes de IA interajam com vaults do Obsidian através de uma API REST local, permitindo ler, escrever, pesquisar e gerenciar notas.