Discover Awesome MCP Servers

Puppeteer MCP Server

Permite a automação do navegador com Puppeteer, suportando navegação, interações com formulários e conexão a instâncias Chrome ativas para uma interação abrangente com páginas da web.

Kokoro TTS MCP Server

Fornece capacidades de conversão de texto em fala através do Protocolo de Contexto do Modelo, permitindo que aplicações integrem facilmente a síntese de fala com vozes personalizáveis, velocidade de fala ajustável e suporte de reprodução de áudio multiplataforma.

mcp-everything-search

This server provides: * Fast file search capabilities using Everything SDK * Windows-specific implementation * Complements existing filesystem servers with specialized search functionality

WebMCP

Uma estrutura que permite que sites compartilhem ferramentas, recursos e prompts com LLMs do lado do cliente sem a necessidade de chaves de API, permitindo que os usuários interajam com serviços da web usando seus modelos preferidos.

Clanki

Um servidor MCP que permite que assistentes de IA, como o Claude, interajam com baralhos de flashcards do Anki, permitindo que os usuários criem, gerenciem e atualizem flashcards por meio de conversas em linguagem natural.

iTerm MCP Server

Este servidor MCP permite que os usuários executem comandos shell na sessão iTerm2 atual através da integração com o Claude Desktop, facilitando a execução de comandos de forma integrada via Protocolo de Contexto do Modelo.

MCP Command Server

Um servidor seguro que permite que aplicações LLM, como Claude, executem comandos de sistema em uma lista de permissões, com confirmação do usuário e recursos de segurança abrangentes.

MCP Accessibility Scanner

Enables automated web accessibility scans for WCAG compliance using Playwright and Axe-core, providing visual and JSON reports with remediation guidance.

Anki MCP Server

Uma implementação de servidor que se conecta a um Anki em execução local, permitindo a revisão e criação de cartões através do Protocolo de Contexto de Modelo.

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.

MCP Notion Server

Uma ponte entre Claude AI e Notion que permite aos usuários interagir com bancos de dados e páginas do Notion através de linguagem natural, suportando operações como criar, ler, atualizar e excluir conteúdo.

MCP TODO Checklist Server

Um servidor que implementa um sistema de gerenciamento de listas de verificação com recursos como criação de tarefas, acompanhamento do progresso, persistência de dados e comentários em itens.

Decent-Sampler Drums MCP Server

Facilita a criação de configurações de kits de bateria DecentSampler, oferecendo suporte à análise de arquivos WAV e geração de XML para garantir comprimentos de amostra precisos e presets bem estruturados.

zendesk-mcp-server

Este servidor oferece uma integração abrangente com o Zendesk. Recuperação e gerenciamento de tickets e comentários. Análise de tickets e redação de respostas. Acesso a artigos da central de ajuda como base de conhecimento.

DocuMind MCP Server

Um servidor de Protocolo de Contexto de Modelo que analisa e avalia a qualidade da documentação README do GitHub usando processamento neural avançado, fornecendo pontuações e sugestões de melhoria.

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.

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.

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.

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

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.

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

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.

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.

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.

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

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.