Discover Awesome MCP Servers

Flutter MCP Server

A TypeScript-based MCP server that implements a simple notes system, enabling users to manage text notes with creation and summarization functionalities through structured prompts.

Waldzell Metagames Server

Provides access to 27+ structured problem-solving frameworks and game-theoretic workflows for software development, project management, and operations research. Helps prevent analysis paralysis and scope creep by transforming open-ended challenges into systematic, time-boxed approaches with clear decision gates.

qring-mcp

A quantum-inspired secret manager that anchors API keys to your OS-native vault, preventing plaintext .env leaks. It empowers AI agents with advanced mechanics like multi-environment superposition, linked entanglements, and ephemeral in-memory tunneling.

Fetch MCP Server

Fornece funcionalidade para buscar e transformar conteúdo da web em vários formatos (HTML, JSON, texto simples e Markdown) por meio de chamadas de API simples.

inked

inked

Logic-Thinking MCP Server

Enables formal logical reasoning, mathematical problem-solving, and proof construction across 11 logic systems including propositional, predicate, modal, fuzzy, and probabilistic logic. Integrates external solvers (Z3, ProbLog, Clingo) for advanced reasoning, with support for proof storage, argument scoring, and cross-system translation.

arXiv Search MCP Server

Um servidor MCP que fornece ferramentas para pesquisar e obter artigos do arXiv.org.

Cursor Auto-Review MCP Server

An MCP server that automates code reviews through linting, testing, and git diff analysis. It also generates conventional commit messages and detailed pull request descriptions based on file changes and code patterns.

Postman MCP Generator

Generates MCP servers from Postman API collections, automatically converting selected API requests into MCP-compatible tools that can be used with Claude Desktop and other MCP clients.

Basic MCP

A simple MCP server built with FastMCP for experimentation and learning purposes. Includes basic web tools like article fetching and serves as a human-readable template for building custom MCP servers.

DatahubMCP

Enables Claude to query MySQL databases and access Google Workspace (Sheets, Forms, Drive) for education program management, with built-in templates for data analysis and report generation.

YApi MCP Server

Enables reading and searching API documentation from YApi instances, allowing AI models to access interface definitions, project API lists, and search through API endpoints using YApi URLs or project IDs.

AI Pull Request Generator

An AI-powered FastMCP server tool that automates the process of planning tasks, generating code, and creating GitHub pull requests.

LibreOffice MCP Server

Enables AI assistants to create, read, edit, and manipulate LibreOffice documents with support for track changes, comments, search/replace, and real-time document operations through a native extension or HTTP API.

Affinity MCP Server

Enables AI assistants to control the Affinity creative suite on macOS through natural language, allowing for automated design tasks, UI interaction, and file operations. It leverages AppleScript and System Events to bridge AI commands with professional creative software.

APK Security Guard MCP Suite

Provides a one-stop automated solution for Android APK security analysis by integrating tools like JEB, JADX, APKTOOL, FlowDroid, and MobSF into unified MCP standard API interfaces.

Futuristic Risk Intelligence

Geopolitical conflict risk data for AI agents

ZenTao MCP Server

Enables LLMs to interact with ZenTao project management system, supporting project and task management operations including creating, querying, and updating projects and tasks through natural language.

Debugg AI MCP

Debugg AI MCP

AI Agent with MCP

Okay, here's a basic outline and code snippets to help you create your first MCP (Model Context Protocol) server in a Playground environment. Keep in mind that MCP is a complex protocol, and this will be a simplified example to get you started. It will focus on the core concepts. **Understanding MCP (Simplified)** * **Purpose:** MCP is used for communication between modeling tools (like 3D modeling software) and a server that provides context and data. Think of it as a way for your modeling software to ask questions and get information from a central source. * **Client/Server:** Your modeling tool is the *client*, and the code you'll write in the Playground will be the *server*. * **Messages:** MCP uses messages to communicate. These messages are typically structured data (often using JSON or a similar format). * **Key Concepts:** * **Context:** The server provides context about the model being worked on. This might include information about the scene, objects, materials, etc. * **Queries:** The client sends queries to the server to request specific information. * **Responses:** The server sends responses back to the client with the requested information. **Simplified Example (Python with Flask)** This example uses Python and the Flask web framework to create a simple MCP server. Flask is easy to use for creating basic web services. ```python from flask import Flask, request, jsonify app = Flask(__name__) # In-memory "model context" (replace with your actual data) model_context = { "scene_name": "MyScene", "object_count": 10, "materials": ["Metal", "Wood", "Glass"] } @app.route('/mcp', methods=['POST']) def mcp_handler(): """Handles MCP requests.""" try: data = request.get_json() # Get the JSON data from the request if data is None: return jsonify({"error": "Invalid JSON data"}), 400 # **Simplified Query Handling** query_type = data.get("query_type") # Example: "get_scene_info" if query_type == "get_scene_info": response_data = { "scene_name": model_context["scene_name"], "object_count": model_context["object_count"] } return jsonify(response_data), 200 # 200 OK elif query_type == "get_materials": response_data = { "materials": model_context["materials"] } return jsonify(response_data), 200 else: return jsonify({"error": "Unknown query type"}), 400 except Exception as e: print(f"Error processing request: {e}") # Log the error return jsonify({"error": "Internal server error"}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Make sure port is open ``` **Explanation:** 1. **Imports:** Imports the necessary libraries (Flask for the web server, `request` to handle incoming requests, and `jsonify` to create JSON responses). 2. **Flask App:** Creates a Flask application instance. 3. **`model_context`:** This is a *placeholder* for your actual model data. In a real MCP server, this would be a much more complex data structure representing the state of your model. It's currently just a Python dictionary. 4. **`/mcp` Route:** This defines the endpoint where the MCP server will receive requests. It uses the `POST` method because MCP requests typically send data to the server. 5. **`mcp_handler()` Function:** * **Get JSON Data:** Retrieves the JSON data from the incoming request using `request.get_json()`. * **Error Handling:** Checks if the JSON data is valid. * **Query Handling (Simplified):** * It extracts a `query_type` from the JSON data. This is a very basic way to determine what the client is asking for. * It uses `if/elif/else` to handle different query types. For example, if `query_type` is `"get_scene_info"`, it creates a response with the scene name and object count. * **Important:** This is a *very* simplified query handling mechanism. A real MCP server would likely use a more sophisticated approach to parse and process queries. * **Response:** It uses `jsonify()` to create a JSON response and returns it with an appropriate HTTP status code (e.g., 200 for success, 400 for bad request, 500 for internal server error). * **Error Handling (try...except):** Includes a `try...except` block to catch any errors that might occur during request processing. This is important for preventing the server from crashing. 6. **`app.run()`:** Starts the Flask development server. `debug=True` enables debugging mode (useful for development). `host='0.0.0.0'` makes the server accessible from other machines on the network (important if your modeling tool is running on a different machine). `port=5000` specifies the port number. **How to Run in a Playground (e.g., Google Colab):** 1. **Install Flask:** If you're using a Playground environment like Google Colab, you'll need to install Flask: ```bash !pip install flask ``` 2. **Copy and Paste:** Copy the Python code above into a code cell in your Playground. 3. **Run the Cell:** Execute the code cell. The Flask server will start running. You'll likely see output indicating that the server is running on `http://0.0.0.0:5000/`. 4. **Make the Server Publicly Accessible (Important for Colab):** Google Colab, by default, doesn't expose the server directly. You'll need to use a tool like `ngrok` to create a public URL that you can use to access your server from your modeling tool. ```python !pip install pyngrok from pyngrok import ngrok # Open a HTTP tunnel on port 5000 public_url = ngrok.connect(5000).public_url print("Ngrok tunnel URL:", public_url) ``` This will give you a URL like `https://your-random-string.ngrok.io`. **Use this URL in your modeling tool to connect to the MCP server.** Remember that the ngrok tunnel will close when your Colab session ends. **Example Client (Python - for testing):** This is a simple Python script to *simulate* a client sending requests to your MCP server. You can run this in a separate code cell in your Playground or from your local machine. ```python import requests import json # Replace with your ngrok URL (or localhost if running locally) SERVER_URL = "https://your-random-string.ngrok.io/mcp" # Or "http://localhost:5000/mcp" def send_mcp_request(query_type): """Sends an MCP request to the server.""" payload = {"query_type": query_type} headers = {'Content-type': 'application/json'} # Important! try: response = requests.post(SERVER_URL, data=json.dumps(payload), headers=headers) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) data = response.json() print(f"Response for {query_type}: {data}") except requests.exceptions.RequestException as e: print(f"Error sending request: {e}") # Example usage send_mcp_request("get_scene_info") send_mcp_request("get_materials") send_mcp_request("unknown_query") # Test error handling ``` **Explanation of the Client:** 1. **Imports:** Imports the `requests` library for making HTTP requests and the `json` library for working with JSON data. 2. **`SERVER_URL`:** **Crucially, replace `"https://your-random-string.ngrok.io/mcp"` with the actual URL provided by ngrok (or `"http://localhost:5000/mcp"` if you're running the server locally).** 3. **`send_mcp_request()` Function:** * **Payload:** Creates a JSON payload with the `query_type`. * **Headers:** Sets the `Content-type` header to `application/json`. **This is essential!** The server needs to know that the data is in JSON format. * **`requests.post()`:** Sends a POST request to the server URL with the JSON payload. * **Error Handling:** Uses `response.raise_for_status()` to check for HTTP errors (like 404 Not Found or 500 Internal Server Error). Also includes a `try...except` block to catch network errors. * **Response:** Parses the JSON response from the server and prints it to the console. 4. **Example Usage:** Calls `send_mcp_request()` with different query types to test the server. **Key Improvements and Considerations for a Real MCP Server:** * **Data Model:** Replace the simple `model_context` dictionary with a proper data model that represents your 3D scene and its objects. Consider using classes or data structures that are appropriate for your modeling tool. * **Query Language:** Instead of simple `query_type` strings, use a more expressive query language (e.g., a subset of SQL, GraphQL, or a custom query language) to allow clients to request specific data. * **Data Serialization:** Choose a data serialization format (JSON, Protocol Buffers, MessagePack, etc.) that is efficient and well-suited for your needs. Protocol Buffers and MessagePack are often preferred for performance. * **Authentication/Authorization:** If your MCP server needs to be secure, implement authentication and authorization mechanisms to control access to the data. * **Real-time Updates:** Consider using WebSockets or Server-Sent Events (SSE) to provide real-time updates to the client when the model data changes. * **Error Handling:** Implement robust error handling and logging to help you debug and maintain the server. * **Scalability:** If you need to support a large number of clients, consider using a more scalable web framework (e.g., ASGI frameworks like FastAPI or Starlette) and a database that can handle the load. * **MCP Specification:** Refer to the actual MCP specification (if one exists for your specific modeling tool) for details on the required message formats and protocols. The term "MCP" can be used in different contexts, so make sure you understand the specific protocol you need to implement. **In summary, this is a very basic starting point. Building a real MCP server is a significant undertaking that requires careful design and implementation.** This example provides a foundation for understanding the core concepts and experimenting with the protocol. Remember to adapt the code to your specific needs and the requirements of your modeling tool. Good luck! **Tradução para Português:** Ok, aqui está um esboço básico e trechos de código para ajudá-lo a criar seu primeiro servidor MCP (Model Context Protocol) em um ambiente Playground. Lembre-se de que o MCP é um protocolo complexo, e este será um exemplo simplificado para você começar. Ele se concentrará nos conceitos principais. **Entendendo o MCP (Simplificado)** * **Propósito:** O MCP é usado para comunicação entre ferramentas de modelagem (como software de modelagem 3D) e um servidor que fornece contexto e dados. Pense nisso como uma maneira do seu software de modelagem fazer perguntas e obter informações de uma fonte central. * **Cliente/Servidor:** Sua ferramenta de modelagem é o *cliente*, e o código que você escreverá no Playground será o *servidor*. * **Mensagens:** O MCP usa mensagens para se comunicar. Essas mensagens são normalmente dados estruturados (geralmente usando JSON ou um formato semelhante). * **Conceitos Chave:** * **Contexto:** O servidor fornece contexto sobre o modelo em que está sendo trabalhado. Isso pode incluir informações sobre a cena, objetos, materiais, etc. * **Consultas:** O cliente envia consultas ao servidor para solicitar informações específicas. * **Respostas:** O servidor envia respostas de volta ao cliente com as informações solicitadas. **Exemplo Simplificado (Python com Flask)** Este exemplo usa Python e o framework web Flask para criar um servidor MCP simples. O Flask é fácil de usar para criar serviços web básicos. ```python from flask import Flask, request, jsonify app = Flask(__name__) # "Contexto do modelo" em memória (substitua pelos seus dados reais) model_context = { "scene_name": "MinhaCena", "object_count": 10, "materials": ["Metal", "Madeira", "Vidro"] } @app.route('/mcp', methods=['POST']) def mcp_handler(): """Lida com as requisições MCP.""" try: data = request.get_json() # Obtém os dados JSON da requisição if data is None: return jsonify({"error": "Dados JSON inválidos"}), 400 # **Tratamento de Consulta Simplificado** query_type = data.get("query_type") # Exemplo: "get_scene_info" if query_type == "get_scene_info": response_data = { "scene_name": model_context["scene_name"], "object_count": model_context["object_count"] } return jsonify(response_data), 200 # 200 OK elif query_type == "get_materials": response_data = { "materials": model_context["materials"] } return jsonify(response_data), 200 else: return jsonify({"error": "Tipo de consulta desconhecido"}), 400 except Exception as e: print(f"Erro ao processar a requisição: {e}") # Registra o erro return jsonify({"error": "Erro interno do servidor"}), 500 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=5000) # Certifique-se de que a porta está aberta ``` **Explicação:** 1. **Imports:** Importa as bibliotecas necessárias (Flask para o servidor web, `request` para lidar com as requisições de entrada e `jsonify` para criar respostas JSON). 2. **Flask App:** Cria uma instância do aplicativo Flask. 3. **`model_context`:** Este é um *placeholder* para seus dados de modelo reais. Em um servidor MCP real, esta seria uma estrutura de dados muito mais complexa representando o estado do seu modelo. Atualmente, é apenas um dicionário Python. 4. **Rota `/mcp`:** Define o endpoint onde o servidor MCP receberá as requisições. Usa o método `POST` porque as requisições MCP normalmente enviam dados para o servidor. 5. **Função `mcp_handler()`:** * **Obtém Dados JSON:** Recupera os dados JSON da requisição de entrada usando `request.get_json()`. * **Tratamento de Erros:** Verifica se os dados JSON são válidos. * **Tratamento de Consulta (Simplificado):** * Extrai um `query_type` dos dados JSON. Esta é uma maneira muito básica de determinar o que o cliente está pedindo. * Usa `if/elif/else` para lidar com diferentes tipos de consulta. Por exemplo, se `query_type` for `"get_scene_info"`, ele cria uma resposta com o nome da cena e a contagem de objetos. * **Importante:** Este é um mecanismo de tratamento de consulta *muito* simplificado. Um servidor MCP real provavelmente usaria uma abordagem mais sofisticada para analisar e processar as consultas. * **Resposta:** Usa `jsonify()` para criar uma resposta JSON e a retorna com um código de status HTTP apropriado (por exemplo, 200 para sucesso, 400 para requisição inválida, 500 para erro interno do servidor). * **Tratamento de Erros (try...except):** Inclui um bloco `try...except` para capturar quaisquer erros que possam ocorrer durante o processamento da requisição. Isso é importante para evitar que o servidor trave. 6. **`app.run()`:** Inicia o servidor de desenvolvimento Flask. `debug=True` habilita o modo de depuração (útil para desenvolvimento). `host='0.0.0.0'` torna o servidor acessível de outras máquinas na rede (importante se sua ferramenta de modelagem estiver rodando em uma máquina diferente). `port=5000` especifica o número da porta. **Como Executar em um Playground (por exemplo, Google Colab):** 1. **Instale o Flask:** Se você estiver usando um ambiente Playground como o Google Colab, precisará instalar o Flask: ```bash !pip install flask ``` 2. **Copie e Cole:** Copie o código Python acima em uma célula de código no seu Playground. 3. **Execute a Célula:** Execute a célula de código. O servidor Flask começará a rodar. Você provavelmente verá uma saída indicando que o servidor está rodando em `http://0.0.0.0:5000/`. 4. **Torne o Servidor Publicamente Acessível (Importante para o Colab):** O Google Colab, por padrão, não expõe o servidor diretamente. Você precisará usar uma ferramenta como o `ngrok` para criar uma URL pública que você possa usar para acessar seu servidor a partir da sua ferramenta de modelagem. ```python !pip install pyngrok from pyngrok import ngrok # Abre um túnel HTTP na porta 5000 public_url = ngrok.connect(5000).public_url print("URL do túnel Ngrok:", public_url) ``` Isso lhe dará uma URL como `https://sua-string-aleatoria.ngrok.io`. **Use esta URL na sua ferramenta de modelagem para se conectar ao servidor MCP.** Lembre-se de que o túnel ngrok será fechado quando sua sessão do Colab terminar. **Exemplo de Cliente (Python - para teste):** Este é um script Python simples para *simular* um cliente enviando requisições para o seu servidor MCP. Você pode executar isso em uma célula de código separada no seu Playground ou a partir da sua máquina local. ```python import requests import json # Substitua pela sua URL ngrok (ou localhost se estiver rodando localmente) SERVER_URL = "https://sua-string-aleatoria.ngrok.io/mcp" # Ou "http://localhost:5000/mcp" def send_mcp_request(query_type): """Envia uma requisição MCP para o servidor.""" payload = {"query_type": query_type} headers = {'Content-type': 'application/json'} # Importante! try: response = requests.post(SERVER_URL, data=json.dumps(payload), headers=headers) response.raise_for_status() # Lança HTTPError para respostas ruins (4xx ou 5xx) data = response.json() print(f"Resposta para {query_type}: {data}") except requests.exceptions.RequestException as e: print(f"Erro ao enviar a requisição: {e}") # Exemplo de uso send_mcp_request("get_scene_info") send_mcp_request("get_materials") send_mcp_request("unknown_query") # Testa o tratamento de erros ``` **Explicação do Cliente:** 1. **Imports:** Importa a biblioteca `requests` para fazer requisições HTTP e a biblioteca `json` para trabalhar com dados JSON. 2. **`SERVER_URL`:** **Crucialmente, substitua `"https://sua-string-aleatoria.ngrok.io/mcp"` pela URL real fornecida pelo ngrok (ou `"http://localhost:5000/mcp"` se você estiver rodando o servidor localmente).** 3. **Função `send_mcp_request()`:** * **Payload:** Cria um payload JSON com o `query_type`. * **Headers:** Define o cabeçalho `Content-type` para `application/json`. **Isso é essencial!** O servidor precisa saber que os dados estão em formato JSON. * **`requests.post()`:** Envia uma requisição POST para a URL do servidor com o payload JSON. * **Tratamento de Erros:** Usa `response.raise_for_status()` para verificar se há erros HTTP (como 404 Not Found ou 500 Internal Server Error). Também inclui um bloco `try...except` para capturar erros de rede. * **Resposta:** Analisa a resposta JSON do servidor e a imprime no console. 4. **Exemplo de Uso:** Chama `send_mcp_request()` com diferentes tipos de consulta para testar o servidor. **Melhorias Chave e Considerações para um Servidor MCP Real:** * **Modelo de Dados:** Substitua o simples dicionário `model_context` por um modelo de dados adequado que represente sua cena 3D e seus objetos. Considere usar classes ou estruturas de dados que sejam apropriadas para sua ferramenta de modelagem. * **Linguagem de Consulta:** Em vez de strings `query_type` simples, use uma linguagem de consulta mais expressiva (por exemplo, um subconjunto de SQL, GraphQL ou uma linguagem de consulta personalizada) para permitir que os clientes solicitem dados específicos. * **Serialização de Dados:** Escolha um formato de serialização de dados (JSON, Protocol Buffers, MessagePack, etc.) que seja eficiente e adequado para suas necessidades. Protocol Buffers e MessagePack são frequentemente preferidos para desempenho. * **Autenticação/Autorização:** Se o seu servidor MCP precisar ser seguro, implemente mecanismos de autenticação e autorização para controlar o acesso aos dados. * **Atualizações em Tempo Real:** Considere usar WebSockets ou Server-Sent Events (SSE) para fornecer atualizações em tempo real ao cliente quando os dados do modelo mudarem. * **Tratamento de Erros:** Implemente tratamento de erros e registro robustos para ajudá-lo a depurar e manter o servidor. * **Escalabilidade:** Se você precisar suportar um grande número de clientes, considere usar um framework web mais escalável (por exemplo, frameworks ASGI como FastAPI ou Starlette) e um banco de dados que possa lidar com a carga. * **Especificação MCP:** Consulte a especificação MCP real (se existir uma para sua ferramenta de modelagem específica) para obter detalhes sobre os formatos de mensagem e protocolos necessários. O termo "MCP" pode ser usado em diferentes contextos, portanto, certifique-se de entender o protocolo específico que você precisa implementar. **Em resumo, este é um ponto de partida muito básico. Construir um servidor MCP real é uma tarefa significativa que requer design e implementação cuidadosos.** Este exemplo fornece uma base para entender os conceitos principais e experimentar o protocolo. Lembre-se de adaptar o código às suas necessidades específicas e aos requisitos da sua ferramenta de modelagem. Boa sorte!

Figma i18n MCP Server

Extracts text nodes from Figma designs and organizes them into structured JSON for internationalization workflows. It enables users to pull content from specific frames or entire files to automatically generate translation keys.

Link Scan MCP Server

Automatically scans and summarizes video links (YouTube, Instagram Reels) and text links (blogs, articles) using AI-powered transcription and summarization. Provides concise 3-sentence summaries without requiring API keys.

MCP Director

An intelligent orchestration server that routes user requests to appropriate specialized MCP servers and manages complex workflows.

YouTube Comments MCP Server

Enables fetching and analyzing YouTube video comments and replies through the YouTube Data API. Supports sorting by relevance or time and returns structured JSON data for comment analysis, summarization, and translation tasks.

Wassenger WhatsApp MCP Server

Enables AI assistants to send messages, analyze conversations, manage chats and groups, schedule messages, and automate WhatsApp business operations through the Wassenger API using natural language commands.

Paylocity MCP Server

Connects Claude Desktop to the Paylocity API to manage employee records, pay statements, and company headcount data through natural language. It includes automated data protection that redacts sensitive information like SSNs and bank account numbers before reaching the model.

Xiaohongshu (XHS) Creator Toolkit

An automation toolkit that enables AI-driven content publishing and creator data analysis for Xiaohongshu via the MCP protocol. It supports automated posting of image and video notes, cookie management, and performance metric tracking through natural language conversations.

PDF Reader MCP Server (@shtse8/pdf-reader-mcp)

Um servidor MCP construído com Node.js/TypeScript que permite que agentes de IA leiam arquivos PDF com segurança (locais ou URL) e extraiam texto, metadados ou contagens de páginas. Utiliza pdf-parse.