Discover Awesome MCP Servers

onx-mcp-server

Explorando o protocolo de contexto do modelo construindo um servidor MCP.

MCP Vulnerability Management System

Um sistema abrangente que ajuda as organizações a rastrear, gerenciar e responder a vulnerabilidades de segurança de forma eficaz por meio de recursos como rastreamento de vulnerabilidades, gerenciamento de usuários, tickets de suporte, gerenciamento de chaves de API e gerenciamento de certificados SSL.

Multi-agent Communication Protocol Server

A standardized interface for agent-to-agent communication that enables composability, supports streaming, and implements server-sent events (SSE) for real-time interaction.

HDFS MCP Server

A Model Context Protocol server that enables interaction with Hadoop Distributed File System, allowing operations like listing, reading, writing, and managing HDFS files and directories.

Simple MCP Server

A minimalist MCP server that provides a single tool to retrieve a developer name, demonstrating the basic structure for Claude's Model Completion Protocol integration.

Fortune MCP Server

Enables users to perform tarot card readings and generate horoscopes based on specified dates, times, and locations. Provides mystical divination services through tarot draws and astrological calculations.

mcp_stdio2sse

Versão SSE dos servidores Stdio MCP

USolver

A best-effort universal logic and numerical solver interface using MCP that implements the 'LLM sandwich' model to process queries, call dedicated solvers (ortools, cvxpy, z3), and verbalize results.

ScreenshotOne MCP Server

A simple implementation of an MCP server for the ScreenshotOne API

Google Cloud DNS API MCP Server

Auto-generated MCP server that enables interaction with Google's Cloud DNS API for managing DNS zones and records through natural language.

AskTheApi Team Builder

Construtor de rede de agentes para comunicação com APIs OpenAPI. Baseado em AutoGen.

Planning Center Online API and MCP Server Integration

Servidor MCP do Planning Center Online

mcp_server

Okay, I can help you outline the steps and provide some code snippets to guide you in implementing a sample MCP (Microcontroller Communication Protocol) server using a Dolphin MCP client. Keep in mind that this is a general outline, and the specific details will depend on your exact requirements, the microcontroller you're using, and the Dolphin MCP client library you're working with. **Conceptual Overview** 1. **Understand the MCP Protocol:** Make sure you have a good understanding of the MCP protocol itself. This includes the message format, command codes, data types, and error handling. The Dolphin MCP client documentation should be your primary source for this. 2. **Choose a Microcontroller and Development Environment:** Select a microcontroller (e.g., Arduino, ESP32, STM32) and the corresponding development environment (e.g., Arduino IDE, PlatformIO, STM32CubeIDE). 3. **Set up Communication:** Decide on the communication interface between the microcontroller and the Dolphin MCP client (typically serial/UART, but could also be SPI or I2C). 4. **Implement the MCP Server Logic:** This is the core of your implementation. You'll need to: * Receive MCP messages from the client. * Parse the messages to extract the command code and data. * Execute the appropriate action based on the command code. * Prepare a response message (if required by the protocol). * Send the response message back to the client. **Steps and Code Snippets (Illustrative - Adapt to Your Specifics)** **1. Project Setup (Example: Arduino IDE with Serial Communication)** * **Install the Arduino IDE:** Download and install the Arduino IDE from the official website. * **Select Your Board:** In the Arduino IDE, go to `Tools > Board` and select the appropriate board for your microcontroller. * **Select Your Port:** Go to `Tools > Port` and select the serial port that your microcontroller is connected to. **2. Basic Serial Communication (Arduino Example)** ```arduino void setup() { Serial.begin(115200); // Adjust baud rate as needed while (!Serial); // Wait for serial port to connect (needed for some boards) Serial.println("MCP Server Started"); } void loop() { if (Serial.available() > 0) { // Read data from the serial port String receivedData = Serial.readStringUntil('\n'); // Read until newline character receivedData.trim(); // Remove leading/trailing whitespace Serial.print("Received: "); Serial.println(receivedData); // **TODO: Parse the MCP message and process it here** // **This is where you'll implement the MCP protocol logic** // Example: Send a simple response Serial.println("Response: OK"); } } ``` **3. MCP Message Parsing and Handling (Illustrative)** This is the most complex part. You'll need to define the structure of your MCP messages and implement the parsing logic. Here's a very basic example assuming a simple text-based MCP protocol: ```arduino // Example MCP Message Format (Text-based): // <COMMAND>:<DATA> // Example Commands: // GET_VALUE:sensor1 // SET_VALUE:led1,1 (LED 1 ON) void processMCPMessage(String message) { int separatorIndex = message.indexOf(':'); if (separatorIndex == -1) { Serial.println("Error: Invalid MCP message format"); return; } String command = message.substring(0, separatorIndex); String data = message.substring(separatorIndex + 1); command.trim(); data.trim(); Serial.print("Command: "); Serial.println(command); Serial.print("Data: "); Serial.println(data); if (command == "GET_VALUE") { // Handle GET_VALUE command if (data == "sensor1") { // Read sensor value (replace with actual sensor reading) int sensorValue = analogRead(A0); String response = "VALUE:" + String(sensorValue); Serial.println(response); } else { Serial.println("Error: Unknown sensor"); } } else if (command == "SET_VALUE") { // Handle SET_VALUE command int commaIndex = data.indexOf(','); if (commaIndex == -1) { Serial.println("Error: Invalid SET_VALUE data format"); return; } String target = data.substring(0, commaIndex); String valueStr = data.substring(commaIndex + 1); target.trim(); valueStr.trim(); if (target == "led1") { int value = valueStr.toInt(); digitalWrite(LED_BUILTIN, value); // Assuming LED_BUILTIN is defined Serial.println("Response: LED set"); } else { Serial.println("Error: Unknown target"); } } else { Serial.println("Error: Unknown command"); } } void loop() { if (Serial.available() > 0) { String receivedData = Serial.readStringUntil('\n'); receivedData.trim(); Serial.print("Received: "); Serial.println(receivedData); processMCPMessage(receivedData); // Call the MCP message processing function } } ``` **4. Error Handling** * Implement error checking at each stage (message parsing, command execution, etc.). * Send appropriate error responses back to the client. **5. Dolphin MCP Client Integration** * **Understand the Dolphin MCP Client API:** Carefully study the Dolphin MCP client library's documentation. This will tell you how to send commands, receive responses, and handle errors from the client side. * **Test Communication:** Use the Dolphin MCP client to send commands to your microcontroller server and verify that the server is correctly processing them and sending back the expected responses. **Important Considerations and Improvements** * **Data Types:** Handle different data types (integers, floats, strings) correctly. You might need to use functions like `toInt()`, `toFloat()`, and string manipulation techniques. * **Binary vs. Text-Based Protocol:** Consider using a binary protocol for efficiency and reduced overhead. This will require more complex parsing and packing of data. * **State Management:** If your server needs to maintain state (e.g., the current value of a variable), implement appropriate state management logic. * **Concurrency:** If you need to handle multiple requests concurrently, consider using interrupts or a real-time operating system (RTOS). * **Security:** If security is a concern, implement appropriate security measures (e.g., authentication, encryption). * **Robustness:** Add error handling and input validation to make your server more robust. * **Testing:** Thoroughly test your server with different commands and data values to ensure that it is working correctly. **Example Dolphin MCP Client Code (Illustrative - Adapt to Your Client Library)** This is a *very* generic example. You'll need to consult the Dolphin MCP client library's documentation for the correct API calls. ```python # Example using a hypothetical Dolphin MCP client library import dolphin_mcp # Configure the connection (e.g., serial port) client = dolphin_mcp.MCPClient(port="/dev/ttyACM0", baudrate=115200) try: client.connect() # Send a GET_VALUE command response = client.send_command("GET_VALUE", "sensor1") print("GET_VALUE Response:", response) # Send a SET_VALUE command response = client.send_command("SET_VALUE", "led1,1") # Turn LED on print("SET_VALUE Response:", response) response = client.send_command("SET_VALUE", "led1,0") # Turn LED off print("SET_VALUE Response:", response) except dolphin_mcp.MCPError as e: print("MCP Error:", e) finally: client.disconnect() ``` **Key Takeaways** * **Understand the MCP Protocol:** This is the foundation. * **Start Simple:** Begin with a basic implementation and gradually add features. * **Test Thoroughly:** Test each component as you build it. * **Consult Documentation:** Refer to the documentation for your microcontroller, development environment, and Dolphin MCP client library. * **Adapt the Code:** The code snippets provided are illustrative. You'll need to adapt them to your specific requirements. Remember to replace the placeholder code with your actual implementation logic. Good luck! Let me know if you have more specific questions as you work through the implementation.

MCP Server Implementation Guide

## Guia e Implementação para Criar seu Próprio Servidor MCP (Model Control Protocol) para Integração com o Cursor Este guia detalha como criar seu próprio servidor MCP (Model Control Protocol) para integrar com o Cursor, permitindo que você controle modelos de linguagem personalizados ou serviços externos diretamente do seu editor de código. **O que é o MCP (Model Control Protocol)?** O MCP é um protocolo de comunicação leve e flexível projetado para facilitar a interação entre o Cursor e modelos de linguagem externos. Ele permite que o Cursor envie solicitações (como completar código, gerar documentação ou refatorar código) para um servidor externo, que processa a solicitação e retorna uma resposta. **Por que criar seu próprio servidor MCP?** * **Integração com Modelos Personalizados:** Use seus próprios modelos de linguagem treinados ou serviços de terceiros que não são suportados nativamente pelo Cursor. * **Controle Total:** Tenha controle total sobre o processamento das solicitações e a lógica de resposta. * **Personalização:** Adapte o comportamento do Cursor para atender às suas necessidades específicas de desenvolvimento. * **Experimentação:** Explore novas funcionalidades e integrações com modelos de linguagem. **Passo 1: Escolha uma Linguagem de Programação e Framework** Você pode usar qualquer linguagem de programação para criar seu servidor MCP. Algumas opções populares incluem: * **Python:** Com frameworks como Flask ou FastAPI, é fácil criar um servidor web simples e eficiente. * **Node.js:** Com Express.js, você pode criar um servidor web escalável e de alto desempenho. * **Go:** Oferece excelente desempenho e concorrência, ideal para servidores de alta carga. Para este guia, usaremos **Python com FastAPI** como exemplo, devido à sua simplicidade e facilidade de uso. **Passo 2: Instale as Dependências** Crie um ambiente virtual (recomendado) e instale as dependências necessárias: ```bash python3 -m venv .venv source .venv/bin/activate # No Linux/macOS .venv\Scripts\activate # No Windows pip install fastapi uvicorn ``` **Passo 3: Defina a Estrutura do Servidor MCP** Um servidor MCP básico precisa de um endpoint para receber as solicitações do Cursor. Este endpoint geralmente usa o método `POST` e recebe um payload JSON contendo informações sobre a solicitação. Crie um arquivo chamado `main.py` com o seguinte conteúdo: ```python from fastapi import FastAPI, Request, HTTPException from pydantic import BaseModel from typing import Optional app = FastAPI() class MCPRequest(BaseModel): prompt: str language: str context: Optional[str] = None # Adicione outros campos relevantes para sua implementação class MCPResponse(BaseModel): completion: str # Adicione outros campos relevantes para sua implementação @app.post("/mcp") async def handle_mcp_request(request: MCPRequest): """ Endpoint para receber solicitações do Cursor. """ try: # 1. Extrair informações da solicitação prompt = request.prompt language = request.language context = request.context # 2. Processar a solicitação (substitua com sua lógica) # Aqui você integraria com seu modelo de linguagem # Exemplo: completion = f"// Completion for: {prompt} in {language} with context: {context}" # 3. Criar a resposta response = MCPResponse(completion=completion) return response except Exception as e: raise HTTPException(status_code=500, detail=str(e)) ``` **Explicação do Código:** * **`MCPRequest`:** Define a estrutura dos dados esperados na solicitação do Cursor. `prompt` é o texto a ser completado, `language` é a linguagem de programação e `context` pode conter informações adicionais sobre o código ao redor do cursor. Adapte esta classe para incluir todos os campos que seu modelo precisa. * **`MCPResponse`:** Define a estrutura da resposta que o servidor enviará de volta ao Cursor. `completion` é o texto gerado pelo modelo. Adicione outros campos conforme necessário (por exemplo, sugestões de código, documentação, etc.). * **`/mcp` endpoint:** Este é o endpoint que o Cursor usará para enviar solicitações. Ele recebe um objeto `MCPRequest`, processa a solicitação (neste exemplo, apenas cria uma string de exemplo) e retorna um objeto `MCPResponse`. * **Tratamento de Erros:** O bloco `try...except` garante que erros inesperados sejam capturados e retornados ao Cursor com um código de status HTTP 500. **Passo 4: Implemente a Lógica de Processamento da Solicitação** A parte mais importante é substituir o comentário `# 2. Processar a solicitação` com a lógica real para interagir com seu modelo de linguagem. Isso pode envolver: * **Carregar seu modelo de linguagem:** Se você estiver usando um modelo treinado localmente, carregue-o na memória. * **Pré-processar o prompt:** Prepare o prompt para ser usado pelo seu modelo (por exemplo, tokenização, embedding). * **Chamar seu modelo:** Envie o prompt para seu modelo e obtenha a resposta. * **Pós-processar a resposta:** Formate a resposta do modelo para ser usada pelo Cursor. **Exemplo de Integração com um Modelo de Linguagem (Hipotético):** ```python # ... (código anterior) @app.post("/mcp") async def handle_mcp_request(request: MCPRequest): try: prompt = request.prompt language = request.language context = request.context # Supondo que você tenha um objeto 'model' carregado # e uma função 'generate_completion' que recebe o prompt e retorna a completion completion = model.generate_completion(prompt, language, context) response = MCPResponse(completion=completion) return response except Exception as e: raise HTTPException(status_code=500, detail=str(e)) # ... (código posterior) ``` **Passo 5: Execute o Servidor MCP** Use Uvicorn para executar o servidor: ```bash uvicorn main:app --reload ``` Isso iniciará o servidor na porta 8000 (por padrão). Você verá uma mensagem como: ``` INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) ``` **Passo 6: Configure o Cursor para Usar seu Servidor MCP** 1. **Abra as configurações do Cursor:** Vá para `File` -> `Preferences` -> `Settings`. 2. **Procure por "Model Control Protocol":** Digite "mcp" na barra de pesquisa. 3. **Configure as seguintes opções:** * **`Model Control Protocol: Enabled`:** Marque esta caixa para habilitar o MCP. * **`Model Control Protocol: Server URL`:** Insira a URL do seu servidor MCP (por exemplo, `http://127.0.0.1:8000/mcp`). * **`Model Control Protocol: API Key` (Opcional):** Se seu servidor MCP requer autenticação, insira a chave API aqui. Você precisará adicionar a lógica de autenticação ao seu servidor. * **`Model Control Protocol: Timeout` (Opcional):** Defina o tempo limite para as solicitações ao servidor. **Passo 7: Teste a Integração** Abra um arquivo de código no Cursor e comece a digitar. O Cursor deve enviar solicitações para seu servidor MCP e usar as respostas para completar o código. **Considerações Adicionais:** * **Autenticação:** Se você estiver expondo seu servidor MCP para a internet, implemente autenticação para proteger seu modelo de linguagem. Você pode usar chaves API, tokens JWT ou outros métodos de autenticação. * **Escalabilidade:** Se você espera um grande volume de solicitações, considere usar um framework de servidor mais escalável e um banco de dados para armazenar informações sobre os usuários e seus modelos. * **Logging:** Implemente logging para rastrear as solicitações e respostas do servidor, o que pode ser útil para depuração e monitoramento. * **Tratamento de Erros:** Implemente um tratamento de erros robusto para lidar com erros inesperados e retornar mensagens de erro informativas ao Cursor. * **Documentação:** Documente seu servidor MCP para que outros desenvolvedores possam usá-lo e integrá-lo com o Cursor. * **Segurança:** Certifique-se de que seu servidor MCP seja seguro e proteja seus dados contra acesso não autorizado. Use HTTPS para criptografar a comunicação entre o Cursor e o servidor. **Exemplo Completo (com autenticação básica):** ```python from fastapi import FastAPI, Request, HTTPException, Depends from fastapi.security import HTTPBasic, HTTPBasicCredentials from pydantic import BaseModel from typing import Optional from starlette import status app = FastAPI() security = HTTPBasic() class MCPRequest(BaseModel): prompt: str language: str context: Optional[str] = None class MCPResponse(BaseModel): completion: str # Substitua com suas credenciais reais USERS = { "user": "password" } def authenticate_user(credentials: HTTPBasicCredentials = Depends(security)): user = USERS.get(credentials.username) if user is None or user != credentials.password: raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="Incorrect username or password", headers={"WWW-Authenticate": "Basic"}, ) return credentials.username @app.post("/mcp") async def handle_mcp_request(request: MCPRequest, username: str = Depends(authenticate_user)): try: prompt = request.prompt language = request.language context = request.context # Aqui você integraria com seu modelo de linguagem completion = f"// Completion for: {prompt} in {language} by {username}" response = MCPResponse(completion=completion) return response except Exception as e: raise HTTPException(status_code=500, detail=str(e)) ``` **Para executar este exemplo com autenticação:** 1. Instale as dependências: `pip install fastapi uvicorn python-multipart` 2. Execute o servidor: `uvicorn main:app --reload` 3. No Cursor, configure o "Model Control Protocol: Server URL" para `http://127.0.0.1:8000/mcp`. 4. No Cursor, configure o "Model Control Protocol: API Key" para `user:password` (substitua com as credenciais definidas em `USERS`). O Cursor usará a autenticação Basic HTTP para enviar as credenciais. Este guia fornece um ponto de partida para criar seu próprio servidor MCP para integração com o Cursor. Adapte o código e as configurações para atender às suas necessidades específicas e explore as possibilidades de integração com modelos de linguagem personalizados. Lembre-se de priorizar a segurança e a escalabilidade ao implementar seu servidor MCP.

yunxin-mcp-server

yunxin-mcp-server

Text-to-Speech MCP Server

Um servidor MCP (Model Context Protocol) simples que oferece recursos de conversão de texto em fala, escrito em TypeScript.

npm-dev-mcp

MCP server that manages npm run dev processes, automatically detecting projects, running them in the background, monitoring logs, and managing ports.

Weather-server MCP Server

A TypeScript-based MCP server that provides weather information through resources and tools, allowing users to access current weather data and forecast predictions for different cities.

TaskFlow MCP

A task management server that helps AI assistants break down user requests into manageable tasks and track their completion with user approval steps.

MCP Toolkit

A modular toolkit for building extensible tool services that fully supports the MCP 2024-11-05 specification, offering file operations, terminal execution, and network requests.

Deep Research MCP

A Model Context Protocol compliant server that facilitates comprehensive web research by utilizing Tavily's Search and Crawl APIs to gather and structure data for high-quality markdown document creation.

ExecuteAutomation Database Server

A Model Context Protocol server that enables LLMs like Claude to interact with SQLite and SQL Server databases, allowing for schema inspection and SQL query execution.

Cline Code Nexus

Um repositório de teste criado por Cline para verificar a funcionalidade do servidor MCP.

Shopify MCP Server

Enables interaction with Shopify store data through GraphQL API, providing tools for managing products, customers, orders, blogs, and articles.

College Basketball Stats MCP Server

An MCP server for accessing college basketball statistics through the SportsData.io CBB v3 Stats API, enabling AI agents to retrieve and analyze college basketball data through natural language interactions.

amap-weather-server

Um servidor amap-weather com MCP.

Ghost MCP Server

Manage your Ghost blog content directly from Claude, Cursor, or any MCP-compatible client, allowing you to create, edit, search, and delete posts with support for tag management and analytics.