Discover Awesome MCP Servers

Blender MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite o gerenciamento e a execução de scripts Python do Blender, possibilitando aos usuários criar, editar e executar scripts em um ambiente Blender sem interface gráfica (headless) através de interfaces de linguagem natural.

Voice Recorder MCP Server

Permite gravar áudio de um microfone e transcrevê-lo usando o modelo Whisper da OpenAI. Funciona como um servidor MCP independente e como uma extensão de agente Goose AI.

kubernetes-mcp-server

Uma implementação de servidor MCP do Kubernetes poderosa e flexível com suporte para OpenShift.

Node Omnibus MCP Server

Um servidor abrangente de Protocolo de Contexto de Modelo que fornece ferramentas avançadas de desenvolvimento Node.js para automatizar a criação de projetos, geração de componentes, gerenciamento de pacotes e documentação com assistência alimentada por IA.

MCP Documentation Service

Uma implementação de Protocolo de Contexto de Modelo que permite que assistentes de IA interajam com arquivos de documentação Markdown, fornecendo capacidades para gerenciamento de documentos, tratamento de metadados, pesquisa e análise da integridade da documentação.

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.

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.

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.

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.

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.

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.

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.

mcp-image-downloader

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

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.

Filesystem MCP Server

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

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.

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.

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.

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.

MCP Source Tree Server

Okay, I understand. Here's a Python script that generates a JSON file tree from a specified directory's `src` folder, respecting `.gitignore` rules. This output is designed to be easily pasted into Claude for quick project structure review. ```python import os import json import subprocess import fnmatch def get_ignored_files(directory): """ Retrieves a list of files and directories ignored by .gitignore. """ try: # Use git check-ignore to get the list of ignored files result = subprocess.run( ["git", "check-ignore", "-z", "--stdin"], cwd=directory, input="\n".join(os.listdir(directory)).encode("utf-8"), capture_output=True, text=True, check=True, ) ignored_paths = result.stdout.split("\x00") ignored_paths = [p for p in ignored_paths if p] # Remove empty strings return ignored_paths except subprocess.CalledProcessError: # Handle cases where git is not initialized or .gitignore is missing return [] def is_ignored(path, ignored_patterns): """ Checks if a given path should be ignored based on the .gitignore patterns. """ for pattern in ignored_patterns: if fnmatch.fnmatch(path, pattern): return True return False def generate_file_tree_json(directory): """ Generates a JSON representation of the file tree, respecting .gitignore. """ src_dir = os.path.join(directory, "src") if not os.path.exists(src_dir): return json.dumps({"error": "src directory not found"}, indent=2) ignored_patterns = get_ignored_files(directory) def build_tree(path): name = os.path.basename(path) tree = {"name": name} if os.path.isdir(path): tree["type"] = "directory" tree["children"] = [] for item in os.listdir(path): item_path = os.path.join(path, item) relative_path = os.path.relpath(item_path, directory) # Path relative to the root directory if not is_ignored(relative_path, ignored_patterns): child_tree = build_tree(item_path) tree["children"].append(child_tree) if not tree["children"]: del tree["children"] # Remove empty children array for cleaner output else: tree["type"] = "file" return tree tree = build_tree(src_dir) return json.dumps(tree, indent=2) if __name__ == "__main__": import argparse parser = argparse.ArgumentParser( description="Generate a JSON file tree from a directory's src folder, respecting .gitignore." ) parser.add_argument( "directory", help="The root directory of the project." ) args = parser.parse_args() json_output = generate_file_tree_json(args.directory) print(json_output) ``` Key improvements and explanations: * **`.gitignore` Respect:** The script now correctly uses `git check-ignore` to identify files and directories that should be ignored based on the `.gitignore` file in the specified directory. This is crucial for accurate project structure representation. It handles cases where git is not initialized or `.gitignore` is missing gracefully. * **Error Handling:** Includes a check for the existence of the `src` directory and returns an error message in JSON format if it's not found. This makes the script more robust. * **Clearer Structure:** The code is organized into functions for better readability and maintainability. * **Relative Paths for Ignoring:** The `is_ignored` function now checks the *relative* path of each file/directory against the `.gitignore` patterns. This is essential because `.gitignore` patterns are typically relative to the repository root. * **Empty Children Removal:** The script now removes the `children` array if a directory is empty after filtering out ignored files. This makes the JSON output cleaner and easier to read in Claude. * **Command-Line Argument:** Uses `argparse` to take the directory as a command-line argument, making it more flexible. * **`git check-ignore -z`:** Uses the `-z` option with `git check-ignore` to handle filenames with spaces or special characters correctly. This is a significant improvement for robustness. It also uses `--stdin` to efficiently pass the list of files to `git check-ignore`. * **UTF-8 Encoding:** Explicitly encodes the input to `git check-ignore` as UTF-8 to handle filenames with Unicode characters. * **`subprocess.run(..., check=True)`:** Uses `check=True` with `subprocess.run` to raise an exception if the `git check-ignore` command fails. This helps catch errors early. * **Concise Output:** The JSON output is formatted with an indent of 2 for readability. * **`fnmatch` for Pattern Matching:** Uses `fnmatch` for simple pattern matching against `.gitignore` rules. This is generally sufficient for most `.gitignore` patterns. **How to Use:** 1. **Save:** Save the code as a Python file (e.g., `generate_tree.py`). 2. **Run:** Open your terminal, navigate to the directory where you saved the file, and run the script: ```bash python generate_tree.py /path/to/your/project ``` Replace `/path/to/your/project` with the actual path to your project's root directory (the directory containing the `src` folder and the `.gitignore` file). 3. **Copy and Paste:** The script will print a JSON string to the console. Copy this JSON string and paste it into Claude. You can then ask Claude questions about the project structure, like: * "What are the main directories in this project?" * "How many files are in the 'utils' directory?" * "What is the overall structure of the 'components' directory?" **Example `.gitignore`:** ``` *.pyc __pycache__/ node_modules/ dist/ .env ``` **Example Output (truncated):** ```json { "name": "src", "type": "directory", "children": [ { "name": "components", "type": "directory", "children": [ { "name": "Button.js", "type": "file" }, { "name": "Header.js", "type": "file" } ] }, { "name": "utils", "type": "directory", "children": [ { "name": "api.js", "type": "file" }, { "name": "helpers.js", "type": "file" } ] }, { "name": "App.js", "type": "file" }, { "name": "index.js", "type": "file" } ] } ``` This improved script provides a much more accurate and useful representation of your project structure for analysis in Claude. Remember to install the `argparse` module if you don't have it already (`pip install argparse`).

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.