Discover Awesome MCP Servers

WinTerm MCP

Um servidor de Protocolo de Contexto de Modelo que fornece acesso programático ao terminal do Windows, permitindo que modelos de IA interajam com a linha de comando do Windows por meio de ferramentas padronizadas para escrever comandos, ler a saída e enviar sinais de controle.

Textwell MCP Server

Integra o Textwell com o Protocolo de Contexto de Modelo para facilitar operações de texto como escrever e anexar texto através de uma ponte do GitHub Pages.

Scrapbox MCP Server

Um servidor MCP simples baseado em TypeScript que implementa um sistema de notas, permitindo que os usuários criem, listem e gerem resumos de notas de texto via Claude.

Chrome Tools MCP Server

Um servidor MCP que fornece ferramentas para interagir com o Chrome através do seu Protocolo DevTools, permitindo o controle remoto de abas do Chrome para executar JavaScript, capturar screenshots, monitorar o tráfego de rede e muito mais.

Cosense MCP Server

Um servidor MCP que permite ao Claude acessar páginas de projetos Cosense, suportando projetos públicos e privados com autenticação SID opcional.

MCP Alchemy

Conecta o Claude Desktop diretamente a bancos de dados, permitindo que ele explore estruturas de banco de dados, escreva consultas SQL, analise conjuntos de dados e crie relatórios por meio de uma camada de API com ferramentas para exploração de tabelas e execução de consultas.

Draw Things MCP

Uma integração que permite ao Cursor AI gerar imagens através da API Draw Things usando comandos em linguagem natural.

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

MATLAB MCP Server

Integra o MATLAB com IA para executar código, gerar scripts a partir de linguagem natural e acessar a documentação do MATLAB de forma integrada.

Logseq MCP Server

Um servidor que permite que LLMs interajam programaticamente com grafos de conhecimento Logseq, permitindo a criação e o gerenciamento de páginas e blocos.

ticktick-mcp-server

Um servidor MCP para o TickTick que permite interagir com seu sistema de gerenciamento de tarefas TickTick diretamente através do Claude e outros clientes MCP.

MCP Server: SSH Rails Runner

Permite a execução remota segura de comandos do console Rails via SSH para operações somente leitura, planejamento de mutações e execução de alterações aprovadas em um ambiente Rails implantado.

MCP Server Replicate

Uma implementação de servidor FastMCP que facilita o acesso baseado em recursos à inferência de modelos de IA, com foco na geração de imagens através da API Replicate, com recursos como atualizações em tempo real, integração de webhook e gerenciamento seguro de chaves de API.

ConsoleSpy

Uma ferramenta que captura os logs do console do navegador e os disponibiliza no Cursor IDE através do Protocolo de Contexto do Modelo (MCP).

MCP Apple Notes

Um servidor de Protocolo de Contexto de Modelo que permite a pesquisa e recuperação semântica do conteúdo do Apple Notes, permitindo que assistentes de IA acessem, pesquisem e criem notas usando embeddings no dispositivo.

Binary Reader MCP

Um servidor de Protocolo de Contexto de Modelo para leitura e análise de arquivos binários, com suporte inicial para arquivos de recursos do Unreal Engine (.uasset).

Everything Search MCP Server

Fornece integração com o Everything Search Engine, permitindo poderosas capacidades de busca de arquivos através do Protocolo de Contexto do Modelo, com opções de busca avançadas como regex, diferenciação entre maiúsculas e minúsculas e ordenação.

Code MCP

Um servidor MCP que fornece ferramentas para ler, escrever e editar arquivos no sistema de arquivos local.

Gel Database MCP Server

Um servidor MCP baseado em TypeScript que permite que agentes LLM interajam com bancos de dados Gel através de linguagem natural, fornecendo ferramentas para aprender esquemas de banco de dados, validar e executar consultas EdgeQL.

Macrostrat MCP Server

Permite que o Claude consulte dados geológicos abrangentes da API Macrostrat, incluindo unidades geológicas, colunas, minerais e escalas de tempo através da linguagem natural.

MCP Pytest Server

Um servidor Node.js que se integra com o pytest para facilitar as ferramentas de serviço do ModelContextProtocol (MCP), permitindo o registro da execução de testes e o rastreamento do ambiente.

Model Control Plane (MCP) Server

Uma implementação de servidor que fornece uma interface unificada para serviços OpenAI, análise de repositórios Git e operações do sistema de arquivos local através de endpoints de API REST.

Smart Photo Journal MCP Server

Este servidor MCP ajuda os usuários a pesquisar e analisar sua biblioteca de fotos por local, etiquetas e pessoas, oferecendo funcionalidades como análise de fotos e correspondência aproximada (fuzzy matching) para um gerenciamento de fotos aprimorado.

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.

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.

kubernetes-mcp-server

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

Spotify MCP Server

Um servidor que conecta o Claude ao Spotify, permitindo que os usuários controlem a reprodução, pesquisem conteúdo, obtenham informações sobre faixas/álbuns/artistas/playlists e gerenciem a fila do Spotify.

Powerpoint MCP Server

Cria e manipula apresentações PowerPoint com capacidades para adicionar vários tipos de slides, gerar imagens e incorporar tabelas e gráficos através de comandos em linguagem natural.

mcp-installer

Este servidor é um servidor que instala outros servidores MCP para você. Instale-o e você poderá pedir ao Claude para instalar servidores MCP hospedados em npm ou PyPi para você. Requer que o npx e o uv estejam instalados para servidores Node e Python, respectivamente.