Discover Awesome MCP Servers

Algorand MCP Implementation

Um servidor MCP abrangente para interações de ferramentas (mais de 40) e acessibilidade de recursos (mais de 60) com a blockchain Algorand, além de muitos prompts úteis.

Code Summarizer

Permite que ferramentas de LLM como Claude Desktop e Cursor AI acessem e resumam arquivos de código através de um servidor Model Context Protocol, fornecendo acesso estruturado ao conteúdo da base de código sem cópia manual.

Scast

Converte código em diagramas UML e fluxogramas através de análise estática, permitindo a visualização da estrutura do código e a explicação da funcionalidade.

DeepView MCP

Um servidor de Protocolo de Contexto de Modelo que permite que IDEs como Cursor e Windsurf analisem grandes bases de código usando a extensa janela de contexto do Gemini.

MCP Server for RSS3

Uma implementação de servidor MCP que integra a API RSS3, permitindo que os usuários consultem dados de blockchains descentralizadas, plataformas de mídia social e da rede RSS3 por meio de linguagem natural.

IDA Pro MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que assistentes de IA interajam com o IDA Pro para tarefas de engenharia reversa e análise de binários.

memos-mcp-server

A MCP(Model Context Protocol) server for Memos.

datadog-mcp-server

MCP Server for Datadog

vrchat-mcp-osc

Fornece uma ponte entre assistentes de IA e VRChat, permitindo o controle de avatar orientado por IA e interações em ambientes de realidade virtual através do Protocolo de Contexto de Modelo.

MCP Server for Milvus

Um servidor de integração que implementa o Protocolo de Contexto de Modelo, permitindo que aplicações LLM interajam com a funcionalidade do banco de dados vetorial Milvus, possibilitando busca vetorial, gerenciamento de coleções e operações de dados através de linguagem natural.

LLMling

Easy MCP (Model Context Protocol) servers and AI agents, defined as YAML.

Jira MCP Server

Um servidor de Protocolo de Contexto de Modelo que permite que assistentes de IA como o Claude interajam com o Jira, possibilitando tarefas de gerenciamento de projetos como listar projetos, pesquisar problemas, criar tickets e gerenciar sprints por meio de consultas em linguagem natural.

mcp-osint OSINT Server

Servidor MCP para executar várias tarefas de OSINT, aproveitando ferramentas comuns de reconhecimento de rede.

AgentCraft MCP Server

Integra-se com o framework AgentCraft para permitir comunicação e troca de dados seguras entre agentes de IA, suportando tanto agentes de IA empresariais pré-fabricados quanto personalizados.

mcp-excalidraw

Um servidor de Protocolo de Contexto de Modelo que permite que LLMs criem, modifiquem e manipulem diagramas Excalidraw através de uma API estruturada.

@f4ww4z/mcp-mysql-server

Espelho de

MCP SSE demo

demo of MCP SSE server limitations using the bun runtime

ThemeParks.wiki API MCP Server

Servidor MCP da API ThemeParks.wiki

S3 MCP Server

Um servidor de Protocolo de Contexto de Modelo Amazon S3 que permite que Modelos de Linguagem Grandes como o Claude interajam com o armazenamento AWS S3, fornecendo ferramentas para listar buckets, listar objetos e recuperar o conteúdo de objetos.

mcp-server-cli

Model Context Protocol server to run shell scripts or commands

MCP Etherscan Server

Espelho de

MCP SSH Server for Windsurf

Servidor SSH MCP para integração com Windsurf

G-Search MCP

Um servidor MCP poderoso que permite a pesquisa paralela no Google com múltiplas palavras-chave simultaneamente, fornecendo resultados estruturados enquanto lida com CAPTCHAs e simula padrões de navegação do usuário.

Mcp Server Chatsum

Please provide me with the WeChat messages you want me to summarize. I need the text of the messages to be able to summarize them for you.

Japanese Text Analyzer MCP Server

Okay, I understand. I can't directly *execute* code or interact with files on your system. However, I can provide you with a Python script that accomplishes this task. I'll explain the code thoroughly so you can understand how it works and adapt it if needed. Here's the Python script: ```python import os import re import argparse import mojimoji # For normalizing Japanese text import subprocess # For calling MeCab def count_characters_and_words(filepath, language): """ Counts characters (excluding spaces and line breaks) and words in a text file. Args: filepath (str): The path to the text file. language (str): The language of the text file ('en' for English, 'ja' for Japanese). Returns: tuple: A tuple containing (character_count, word_count). Returns (None, None) on error. """ try: with open(filepath, 'r', encoding='utf-8') as f: text = f.read() except FileNotFoundError: print(f"Error: File not found: {filepath}") return None, None except UnicodeDecodeError: print(f"Error: Could not decode file {filepath} with UTF-8. Try a different encoding.") return None, None if language == 'en': # English: Simple word splitting and character counting text = text.strip() # Remove leading/trailing whitespace character_count = len(re.sub(r'\s', '', text)) # Remove all whitespace characters words = text.split() word_count = len(words) elif language == 'ja': # Japanese: Use MeCab for morphological analysis try: # Normalize text to full-width katakana for better MeCab performance normalized_text = mojimoji.zen_to_han(text, kana=False, ascii=False) normalized_text = mojimoji.han_to_zen(normalized_text, kana=True, ascii=False) # Call MeCab mecab_process = subprocess.Popen(['mecab'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True) mecab_output, mecab_error = mecab_process.communicate(normalized_text) if mecab_error: print(f"MeCab Error: {mecab_error}") return None, None # Count words based on MeCab output (first column of each line before the comma) words = [line.split(',')[0].split('\t')[0] for line in mecab_output.splitlines() if line.strip() != 'EOS'] word_count = len(words) # Count characters (excluding spaces and line breaks) character_count = len(re.sub(r'\s', '', text)) except FileNotFoundError: print("Error: MeCab is not installed or not in your PATH.") print("Please install MeCab and ensure it's accessible from the command line.") return None, None except Exception as e: print(f"An error occurred during Japanese processing: {e}") return None, None else: print("Error: Invalid language specified. Use 'en' or 'ja'.") return None, None return character_count, word_count def main(): parser = argparse.ArgumentParser(description="Counts characters and words in text files.") parser.add_argument("filepath", help="The path to the text file.") parser.add_argument("language", help="The language of the text file ('en' for English, 'ja' for Japanese).") args = parser.parse_args() filepath = args.filepath language = args.language char_count, word_count = count_characters_and_words(filepath, language) if char_count is not None and word_count is not None: print(f"File: {filepath}") print(f"Language: {language}") print(f"Character Count (excluding spaces): {char_count}") print(f"Word Count: {word_count}") if __name__ == "__main__": main() ``` **How to Use the Script:** 1. **Save the Code:** Save the code above as a Python file (e.g., `count_text.py`). 2. **Install Dependencies:** You'll need to install the `mojimoji` library and MeCab. Open your terminal or command prompt and run: ```bash pip install mojimoji ``` * **MeCab Installation:** MeCab is a morphological analyzer for Japanese. The installation process varies depending on your operating system: * **Linux (Debian/Ubuntu):** ```bash sudo apt-get update sudo apt-get install mecab libmecab-dev mecab-ipadic-utf8 ``` * **macOS (using Homebrew):** ```bash brew install mecab brew install mecab-ipadic ``` * **Windows:** The installation on Windows is more involved. I recommend following a tutorial like this one: [https://medium.com/@denis.akhapkin/installing-mecab-on-windows-10-8e318304985](https://medium.com/@denis.akhapkin/installing-mecab-on-windows-10-8e318304985). Make sure MeCab is added to your system's PATH environment variable. 3. **Run the Script:** Open your terminal or command prompt, navigate to the directory where you saved `count_text.py`, and run the script with the following command: ```bash python count_text.py <filepath> <language> ``` * Replace `<filepath>` with the actual path to your text file (e.g., `my_english_text.txt` or `my_japanese_text.txt`). * Replace `<language>` with either `en` for English or `ja` for Japanese. **Example:** ```bash python count_text.py my_english_text.txt en python count_text.py my_japanese_text.txt ja ``` **Explanation of the Code:** * **`import` Statements:** * `os`: (Not directly used in the current version, but good practice to include for potential file system operations). * `re`: For regular expressions (used to remove spaces). * `argparse`: For parsing command-line arguments (filepath and language). * `mojimoji`: For normalizing Japanese text (converting between full-width and half-width characters). This is important for MeCab's accuracy. * `subprocess`: For running the MeCab command-line tool. * **`count_characters_and_words(filepath, language)` Function:** * Takes the file path and language as input. * **File Handling:** Opens the file in UTF-8 encoding (important for handling Japanese characters). Includes error handling for `FileNotFoundError` and `UnicodeDecodeError`. * **English Processing (`language == 'en'`):** * Removes leading/trailing whitespace using `text.strip()`. * Counts characters by removing all whitespace characters (using `re.sub(r'\s', '', text)`) and then getting the length of the resulting string. * Splits the text into words using `text.split()`. * Counts the number of words. * **Japanese Processing (`language == 'ja'`):** * **Normalization:** Uses `mojimoji` to normalize the text. It converts half-width characters to full-width katakana and full-width characters to half-width ascii. This improves MeCab's performance. * **MeCab Integration:** * Uses `subprocess.Popen` to run the `mecab` command. * Passes the text to MeCab via standard input (`stdin`). * Captures MeCab's output from standard output (`stdout`). * Captures any errors from standard error (`stderr`). * **Error Handling:** Checks for MeCab errors and prints them if any occur. Also includes a `FileNotFoundError` check to see if MeCab is installed. * **Word Counting:** Parses the MeCab output. MeCab outputs each word on a separate line, with the word itself in the first column (before the first tab character). The code extracts these words and counts them. It skips the "EOS" (End of Sentence) marker. * **Character Counting:** Counts characters in the original text (excluding spaces and line breaks) using `len(re.sub(r'\s', '', text))`. * **Error Handling:** Handles invalid language input. * **Returns:** Returns the character count and word count as a tuple. * **`main()` Function:** * Uses `argparse` to handle command-line arguments. * Calls `count_characters_and_words()` to do the actual counting. * Prints the results. * **`if __name__ == "__main__":` Block:** * Ensures that the `main()` function is only called when the script is run directly (not when it's imported as a module). **Key Improvements and Considerations:** * **Japanese Morphological Analysis (MeCab):** The script now uses MeCab for Japanese word counting. This is *essential* for accurate word counts in Japanese because Japanese doesn't use spaces to separate words. * **Character Counting (Excluding Spaces):** The script correctly counts characters by removing spaces and line breaks using regular expressions. * **UTF-8 Encoding:** The script opens the files with UTF-8 encoding to handle Japanese characters correctly. * **Error Handling:** The script includes error handling for file not found, Unicode decoding errors, and MeCab errors. * **Command-Line Arguments:** The script uses `argparse` to make it easy to specify the file path and language from the command line. * **MeCab Installation:** The script provides instructions for installing MeCab on different operating systems. This is a crucial step. * **Normalization:** The script normalizes the Japanese text before passing it to MeCab. This can improve MeCab's accuracy. * **MeCab PATH:** Make sure MeCab is in your system's PATH environment variable so the script can find it. * **Alternative Japanese Tokenizers:** While MeCab is a good choice, other Japanese tokenizers exist (e.g., SudachiPy, Juman++). You could adapt the script to use a different tokenizer if you prefer. * **Large Files:** For very large files, you might want to consider reading the file in chunks to avoid loading the entire file into memory at once. **Example Usage (with sample files):** 1. **Create `my_english_text.txt`:** ``` This is a sample English text file. It has multiple lines. ``` 2. **Create `my_japanese_text.txt`:** ``` これは日本語のサンプルテキストファイルです。 複数の行があります。 ``` 3. **Run the script:** ```bash python count_text.py my_english_text.txt en python count_text.py my_japanese_text.txt ja ``` The script will print the character and word counts for each file. Remember to install MeCab *before* running the script with a Japanese file.

Notion MCP Server

Um servidor de Protocolo de Contexto de Modelo que fornece uma interface padronizada para modelos de IA acessarem, consultarem e modificarem conteúdo em espaços de trabalho do Notion.

PubMed Enhanced Search Server

Permite a busca e recuperação de artigos acadêmicos do banco de dados PubMed com recursos avançados como pesquisa de termos MeSH, estatísticas de publicação e busca de evidências baseada em PICO.