Discover Awesome MCP Servers

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.

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.

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-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.

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.

mcp-maigret

Servidor MCP para o Maigret, uma ferramenta OSINT poderosa que coleta informações de contas de usuários de várias fontes públicas. Este servidor fornece ferramentas para pesquisar nomes de usuário em redes sociais e analisar URLs.

Cursor A11y MCP

Fornece capacidades de teste de acessibilidade através de CLI, ajudando a identificar problemas de acessibilidade em aplicações web usando axe-core e Puppeteer.

MCP Server Make

Um servidor de Protocolo de Contexto de Modelo que permite que LLMs executem com segurança alvos "make" de um Makefile, permitindo que assistentes de IA executem testes, formatem código e automatizem várias tarefas de desenvolvimento através da interação em linguagem natural.

MCP-AppleMusic

Facilita o controle do Apple Music no macOS via AppleScript através de comandos MCP, permitindo que os usuários gerenciem a reprodução, pesquisem faixas e criem playlists.

kb-mcp-server

Um servidor MCP com o objetivo de ser portátil, local, fácil e conveniente para suportar a recuperação semântica/baseada em grafos de um banco de dados de embeddings "tudo em um" txtai. Qualquer banco de dados de embeddings txtai em formato tar.gz pode ser carregado.

mcp-image-downloader

Permite que assistentes de IA baixem imagens de URLs e realizem tarefas básicas de otimização de imagem.

Filesystem MCP Server

Servidor Go implementando o Protocolo de Contexto de Modelo (MCP) para operações de sistema de arquivos.

MCP Journaling Server

O servidor MCP transforma conversas com Claude em sessões de diário, salvando as conversas localmente e permitindo que o LLM recupere sessões anteriores para criar continuidade em discussões sobre atividades diárias.

Video Editor MCP Server

Permite a edição de vídeo usando comandos em linguagem natural, impulsionada pelo FFmpeg, suportando operações como corte, junção, conversão de formato e muito mais, com rastreamento de progresso em tempo real e tratamento de erros.

Browser Use Server

Permite a automação do navegador usando scripts Python, oferecendo operações como tirar screenshots de páginas da web, recuperar conteúdo HTML e executar JavaScript.

Veri5ight MCP Server

Permite que Claude interaja com nós Ethereum, permitindo que os usuários verifiquem saldos de tokens ENS, visualizem o código de contratos inteligentes e decodifiquem transações por meio de linguagem natural.

Crawl4AI MCP Server

O Crawl4AI MCP Server é um servidor de recuperação de informações inteligente que oferece recursos de busca robustos e compreensão de conteúdo web otimizada para LLMs, utilizando busca multi-engine e extração de conteúdo inteligente para coletar e compreender informações da internet de forma eficiente.

Chroma MCP Server

Um servidor de Protocolo de Contexto de Modelo que fornece capacidades de banco de dados vetorial através do Chroma, permitindo busca semântica de documentos, filtragem de metadados e gerenciamento de documentos com armazenamento persistente.

Git Auto Commit MCP Server

Analisa as alterações do Git em repositórios e gera mensagens de commit convencionais usando os modelos GPT da OpenAI, suportando alterações preparadas (staged) e não preparadas (unstaged) com resumos detalhados.

Tesla MCP Server

Um servidor de Protocolo de Contexto de Modelo que se conecta à API Tesla Fleet, permitindo que assistentes de IA como o Claude controlem veículos Tesla e acessem informações do veículo por meio de comandos em linguagem natural.

YouTube MCP Server

Usando yt-dlp para baixar legendas do YouTube e conectando ao claude.ai via Protocolo de Contexto de Modelo.

Claude Desktop API MCP

Um servidor que permite aos usuários do Claude Desktop acessar a API do Claude diretamente, permitindo-lhes contornar as limitações do Plano Profissional e usar recursos avançados como prompts de sistema personalizados e gerenciamento de conversas.

Airbyte Status Checker

Um servidor MCP para o Claude Desktop que permite aos usuários verificar o status de suas conexões Airbyte.

MCP Server Memory File

Um servidor MCP que permite que Claude e outros LLMs gerenciem memórias persistentes entre conversas através do armazenamento de arquivos de texto, habilitando comandos para adicionar, pesquisar, excluir e listar entradas de memória.

Uber Eats MCP Server

Um servidor de prova de conceito que implementa o Protocolo de Contexto de Modelo, permitindo que aplicações LLM interajam com a funcionalidade do Uber Eats.

mcp-server-multiverse

Um servidor middleware que permite que múltiplas instâncias isoladas dos mesmos servidores MCP coexistam independentemente com namespaces e configurações únicas.

MacOS Clipboard MCP Server

Fornece aos assistentes de IA acesso ao conteúdo da área de transferência do macOS, com suporte para texto, imagens e dados binários via OSAScript.