Discover Awesome MCP Servers

MCP2Brave

Um servidor baseado no protocolo MCP que usa a API Brave para funcionalidade de pesquisa na web.

Laravel Forge MCP Server

A minimalist MCP server that integrates with Laravel Forge, allowing users to manage their Laravel Forge servers, sites, and deployments through AI assistants like Claude Desktop, Windsurf, or Cursor.

facebook-mcp-server

facebook-mcp-server

WhatsApp MCP Server

Implementação de um Servidor MCP (Message Control Protocol) do WhatsApp

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!

focus_mcp_data

O plugin de consulta inteligente de dados do DataFocus, que suporta conversas em várias rodadas, oferece capacidades ChatBI plug-and-play.

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.

Paradex Server

A Model Context Protocol server implementation that enables AI assistants to interact with the Paradex perpetual futures trading platform, allowing for retrieving market data, managing trading accounts, placing orders, and monitoring positions.

Axiom MCP Server

Uma implementação de servidor do Protocolo de Contexto de Modelo para Axiom que permite que agentes de IA consultem seus dados usando a Linguagem de Processamento Axiom (APL).

GitHub MCP Bridge

A Model Context Protocol server that enables AI agents to securely access and interact with GitHub Enterprise data, providing access to enterprise users, organizations, emails, and license information.

MCP

Servidor MCP

YARR Media Stack MCP Server

Um servidor abrangente de Protocolo de Contexto de Modelo que conecta LLMs com serviços de mídia auto-hospedados, permitindo o controle por linguagem natural de programas de TV, filmes, downloads e notificações, mantendo o acesso tradicional à API.

HubSpot CMS MCP Server

An auto-generated Multi-Agent Conversation Protocol Server for interacting with HubSpot CMS API, allowing AI agents to manage HubSpot content management system through natural language commands.

MCP Search Analytics Server

A Model Context Protocol server that provides unified access to Google Analytics 4 and Google Search Console data through real-time analytics queries.

bonk-mcp MCP Server

Implements Solana blockchain functionality for the LetsBonk launchpad, enabling users to launch and trade tokens on letsbonk.fun.

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.

MSSQL Database Connector

Um servidor de Protocolo de Contexto de Modelo que permite executar consultas SQL e gerenciar conexões com bancos de dados Microsoft SQL Server.

Kobold MCP Server

A server enabling integration between KoboldAI's text generation capabilities and MCP-compatible applications, with features like chat completion, Stable Diffusion, and OpenAI-compatible API endpoints.

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.

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.