Discover Awesome MCP Servers

Perplexity MCP Server

Um servidor MCP que permite ao Claude realizar pesquisas na web usando a API da Perplexity com seleção inteligente de modelo com base na intenção da consulta e suporte para filtragem por domínio e data.

Obsidian MCP Server

Permite a interação entre LLMs e vaults do Obsidian através do Protocolo de Contexto do Modelo, suportando operações seguras de arquivos, gerenciamento de conteúdo e capacidades avançadas de busca.

MCP Server Starter

Um modelo pronto para produção para criar servidores de Protocolo de Contexto de Modelo com TypeScript, fornecendo ferramentas para testes, desenvolvimento e implantação eficientes.

Image Generator MCP Server

Um servidor MCP baseado em TypeScript que gera imagens usando o modelo dall-e-3 da OpenAI com base em prompts de texto e as salva em um diretório especificado.

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.

Xano MCP Server

Permite que assistentes de IA gerenciem bancos de dados Xano através do Protocolo de Contexto de Modelo, permitindo que os usuários criem, modifiquem e excluam tabelas, editem esquemas e extraiam documentação da API.

AI Development Assistant MCP Server

Um kit de ferramentas de desenvolvimento com tecnologia de IA para o Cursor, que oferece assistência de codificação inteligente por meio de raciocínio avançado, análise de capturas de tela da interface do usuário e ferramentas de revisão de código.

IAC Memory MCP Server

Um servidor MCP de Memória personalizado que atua como um cache para informações de Infraestrutura como Código, permitindo que os usuários armazenem, resumam e gerenciem notas com um esquema URI personalizado e um tratamento de recursos simples.

Filesystem MCP Server

Um servidor MCP que permite que a IA Claude execute operações no sistema de arquivos, incluindo leitura, escrita, listagem, movimentação de arquivos e busca em diretórios dentro de caminhos permitidos especificados.

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.

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.

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.

mcp-everything-search

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

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.

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.

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.

MCP Accessibility Scanner

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

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.

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.

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.

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.

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.

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.

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.

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.

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