Discover Awesome MCP Servers

MCP Notion Server (@suncreation)

An MCP server that enables LLMs to interact with Notion workspaces via the Notion API, supporting page creation, database management, and content retrieval. It features markdown conversion to optimize token usage and enhanced error handling for more reliable workspace interactions.

MCP Template

A template MCP server built with FastMCP framework that demonstrates basic tool implementation with a simple addition calculator example.

Google Calendar MCP Server

Servidor de Protocolo de Contexto do Modelo (MCP) que se integra com a API do Google Agenda

KaiaFun MCP

Um servidor MCP que permite a listagem, negociação e interação de tokens com a blockchain Kaia através do Claude Desktop.

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!

Debugg AI MCP

Debugg AI MCP

UUID MCP Provider

A simple Model Context Protocol server that provides timestamp-based UUID v7 identifiers when called by an LLM, offering chronologically sortable unique IDs with no input parameters needed.

MCP Unity Editor

Enables AI assistants to interact with Unity Editor through the Model Context Protocol, allowing natural language control of Unity projects including scene manipulation, GameObject creation, component updates, package management, and test execution.

better-godot-mcp

18 composite tools for structured Godot 4.x interaction: scenes, nodes, GDScript, shaders, animation, tilemap, physics, and more.

Kakao Bot MCP Server

An implementation of the Model Context Protocol that connects AI agents to Kakao Official Accounts, allowing users to send various message templates through the Kakao Developers API.

FakeStore MCP

A Model Context Protocol server that enables AI assistants to interact with a complete e-commerce application, providing authentication, product browsing, and shopping cart management through standardized MCP tools.

Karma MCP Server

Enables Claude to interact with Karma Alert dashboard to monitor and analyze Kubernetes alerts. Provides tools to check alert status, filter by cluster/severity, get detailed alert information, and analyze alert statistics and trends.

chess-uci-mcp

Servidor MCP para conectar aos engines de xadrez usando o protocolo UCI.

iMessage Max

Enables AI assistants to read, search, and send iMessages with features like contact name resolution, session grouping, and attachment listing. It provides intent-aligned tools to efficiently navigate conversation history and manage messages through natural language queries.

MCP Veracode

An MCP server that enables users to interact with Veracode security services through Claude Code. It allows for listing applications, retrieving vulnerability findings, checking scan statuses, and monitoring policy compliance.

mcp-server-bitbucket

MCP server with 58 tools for Bitbucket API operations. Manage repositories, pull requests, pipelines, branches, commits, deployments, webhooks, and more.

Palo Alto Networks MCP Server Suite

Enables comprehensive management of Palo Alto Networks firewalls through a modular suite of servers for security policies, network objects, device operations, and system configuration.

Atlassian MCP

Plugin de Código Gerenciado para Cursor IDE, fornecendo integração com produtos Atlassian (JIRA, Confluence, BitBucket), permitindo que desenvolvedores pesquisem tarefas, criem novos problemas, visualizem documentação e gerenciem repositórios de código diretamente do IDE.

Ensembl MCP Server

A Model Context Protocol server providing LLMs with access to the Ensembl genomics database, enabling AI assistants to query gene information, sequences, variants, and other genomic data across multiple species.

Claude File Management Server

Enables Claude AI to perform comprehensive file operations including reading, writing, notes management, PDF processing, and image handling with thread-safe operations. Provides a complete file management system with enhanced features like document processing and automatic directory creation.

Pentest MCP

Um servidor de Protocolo de Contexto de Modelo que integra ferramentas essenciais de teste de penetração (Nmap, Gobuster, Nikto, John the Ripper) em uma interface unificada de linguagem natural, permitindo que profissionais de segurança executem e encadeiem múltiplas ferramentas através de comandos conversacionais.

File System MCP Server

Provides secure file read and write operations within a sandboxed directory, allowing AI assistants to safely create, modify, and access files without risk of accessing the broader file system.

Viterbit MCP Server

Enables interaction with Viterbit recruitment API for managing candidates, jobs, and applications. Supports searching, updating candidate data, handling job applications, and advanced filtering with subscription and activity status tracking.

PDB MCP Server

PDB MCP Server

Delve MCP

Um servidor MCP baseado em TypeScript que fornece uma interface completa para o depurador Delve para programas Go, permitindo depuração, rastreamento e análise de código Go por meio de comandos em linguagem natural.

Mastercard BIN Table MCP Server

An MCP server that provides access to Mastercard's BIN Table Resource API, allowing users to look up and interact with Bank Identification Number data through natural language queries.

SuperiorAPIs MCP Server Tool

Um servidor MCP baseado em Python que busca dinamicamente definições de plugins da SuperiorAPIs e auto-gera funções de ferramentas baseadas em esquemas OpenAPI, permitindo uma integração perfeita com serviços de API.

Server2MCP Spring Boot Starter

Este é um plugin de IA revolucionário com excelentes recursos conectáveis e encapsulados. Com apenas algumas linhas de configuração, ele pode ser facilmente integrado ao seu programa web Spring Boot e fornecer a ele capacidades MCP.

MCPHy

Transform REST APIs into intelligent, chat-driven MCP servers with zero code changes. Simply point it at your Swagger/OpenAPI specification to get natural language querying capabilities powered by AI.