Discover Awesome MCP Servers

MCP Demo

Servidor MCP do Slack com Python

@container-inc/mcp

Servidor MCP para implementações automatizadas no Container Inc.

Local Mcp Server Tutorial

Aqui está um tutorial para criar um servidor MCP local (stdio): **Título: Criando um Servidor MCP Local (stdio)** Este tutorial irá guiá-lo através do processo de criação de um servidor MCP (Minecraft Protocol) local que se comunica através de entrada e saída padrão (stdio). Isso pode ser útil para testes, depuração ou para criar ferramentas personalizadas que interagem com o protocolo Minecraft. **Pré-requisitos:** * **Conhecimento básico de programação:** Este tutorial assume que você tem algum conhecimento básico de programação em uma linguagem de sua escolha (por exemplo, Python, Java, C++). * **Ambiente de desenvolvimento:** Você precisará de um ambiente de desenvolvimento configurado para a linguagem que você escolher. * **Entendimento do protocolo Minecraft (opcional):** Embora não seja estritamente necessário, ter um entendimento básico do protocolo Minecraft ajudará você a entender o que está acontecendo. Você pode encontrar informações sobre o protocolo Minecraft na wiki do Minecraft ou em outros recursos online. **Passos:** 1. **Escolha uma Linguagem de Programação:** Selecione a linguagem de programação que você se sente mais confortável. Python é uma boa escolha para iniciantes devido à sua sintaxe simples e vasta biblioteca. Java e C++ são opções mais poderosas, mas podem ter uma curva de aprendizado mais acentuada. 2. **Configuração do Projeto:** Crie um novo projeto em seu ambiente de desenvolvimento. Organize seu projeto com arquivos para o servidor principal, tratamento de pacotes e qualquer outra funcionalidade que você queira adicionar. 3. **Implementação da Comunicação stdio:** * **Leitura da Entrada Padrão (stdin):** Seu servidor precisará ler dados da entrada padrão. A forma como você faz isso depende da sua linguagem de programação. Por exemplo, em Python, você usaria `sys.stdin.readline()`. * **Escrita na Saída Padrão (stdout):** Seu servidor precisará escrever dados na saída padrão. Novamente, a forma como você faz isso depende da sua linguagem de programação. Por exemplo, em Python, você usaria `print()`. 4. **Análise e Processamento de Pacotes:** * **Formato dos Pacotes:** O protocolo Minecraft usa um formato específico para os pacotes. Você precisará entender esse formato para analisar os dados que recebe e formatar os dados que envia. * **Análise:** Analise os dados recebidos da entrada padrão para determinar o tipo de pacote e seus dados. * **Processamento:** Processe os dados do pacote de acordo com a lógica do seu servidor. 5. **Implementação da Lógica do Servidor:** * **Tratamento de Conexões:** Embora este seja um servidor local, você ainda precisará lidar com o conceito de conexões. Você pode usar um identificador simples para cada "conexão" (por exemplo, um número inteiro). * **Lógica do Jogo:** Implemente a lógica do jogo que você deseja suportar. Isso pode incluir coisas como: * Responder a comandos * Simular o mundo * Gerenciar entidades 6. **Teste:** * **Crie um Cliente:** Você precisará de um cliente para se conectar ao seu servidor. Você pode usar um cliente Minecraft existente (modificado para se conectar ao seu servidor stdio) ou criar um cliente simples para fins de teste. * **Envie e Receba Pacotes:** Envie pacotes do cliente para o servidor e verifique se o servidor os processa corretamente. Envie pacotes do servidor para o cliente e verifique se o cliente os recebe e os interpreta corretamente. **Exemplo Simplificado em Python:** ```python import sys def main(): print("Servidor MCP (stdio) iniciado.") while True: line = sys.stdin.readline().strip() if not line: break # Encerra se a entrada estiver vazia print(f"Recebido: {line}") # Aqui você analisaria 'line' para determinar o tipo de pacote # e processaria os dados. # Exemplo de resposta: if line == "ping": print("pong") else: print("Comando desconhecido.") if __name__ == "__main__": main() ``` **Como Executar:** 1. Salve o código Python como `mcp_server.py`. 2. Abra um terminal ou prompt de comando. 3. Execute o servidor com `python mcp_server.py`. 4. Em outro terminal, você pode enviar comandos para o servidor usando `echo "ping" | python`. Isso enviará a string "ping" para a entrada padrão do servidor. **Considerações Adicionais:** * **Segurança:** Como este é um servidor local, a segurança pode não ser uma grande preocupação. No entanto, se você planeja expor seu servidor à rede, você precisará tomar medidas para proteger contra ataques. * **Desempenho:** A comunicação stdio pode não ser a forma mais eficiente de comunicação. Se você precisar de alto desempenho, considere usar sockets TCP/IP. * **Complexidade do Protocolo Minecraft:** O protocolo Minecraft é bastante complexo. Implementar um servidor completo pode ser um projeto demorado. Comece com funcionalidades básicas e adicione mais recursos gradualmente. * **Bibliotecas:** Considere usar bibliotecas existentes para ajudar com a análise e formatação de pacotes Minecraft. Isso pode economizar muito tempo e esforço. **Conclusão:** Este tutorial fornece um ponto de partida para criar um servidor MCP local (stdio). Lembre-se de que este é um projeto complexo e exigirá um investimento significativo de tempo e esforço. Boa sorte!

Open Food Facts MCP Server

Enables AI assistants to access the Open Food Facts database to query detailed food product information, nutritional data, and environmental scores. Supports product lookup by barcode, smart search with filtering, nutritional analysis, product comparison, and dietary recommendations to help users make informed food choices.

Notion MCP Server

A simple MCP server implementation for Notion integration

Local Falcon MCP Server

Connects AI systems to Local Falcon API, enabling access to local SEO reporting tools including scan reports, trend analysis, keyword tracking, and competitor data through the Model Context Protocol.

UUID MCP Provider

Um servidor simples de Protocolo de Contexto de Modelo que gera UUIDs baseados em timestamp (v7) quando chamado por um LLM, fornecendo identificadores únicos ordenáveis cronologicamente sem a necessidade de parâmetros de entrada.

YaVendió Tools

An MCP-based messaging system that allows AI systems to interact with various messaging platforms through standardized tools for sending text, images, documents, buttons, and alerts.

pumpswap-mcp

pumpswap-mcp

Model Context Protocol (MCP)

Okay, here's a breakdown of a working pattern for SSE (Server-Sent Events) based MCP (Microservice Communication Protocol) clients and servers, leveraging the Gemini LLM (Large Language Model). This pattern focuses on how to use SSE for real-time communication between microservices, with Gemini potentially playing a role in data transformation, enrichment, or decision-making within the microservice architecture. **Core Concepts:** * **Microservices:** A distributed application architecture composed of small, independent, and loosely coupled services. * **MCP (Microservice Communication Protocol):** A standardized way for microservices to communicate. This could be a custom protocol or a well-established one like gRPC, REST, or, in this case, SSE. The key is consistency and clarity. * **SSE (Server-Sent Events):** A unidirectional communication protocol where the server pushes updates to the client over a single HTTP connection. It's ideal for real-time data streams. * **Gemini LLM:** A powerful language model that can be used for various tasks, including text generation, translation, summarization, and more. In this context, it can be integrated into a microservice to process or generate data that is then streamed to other services via SSE. **Architecture Overview:** ``` +---------------------+ SSE +---------------------+ SSE +---------------------+ | Client Microservice | <-----------> | Server Microservice | <-----------> | Client Microservice | | (e.g., UI, Analytics)| | (e.g., Data Processor)| | (e.g., Dashboard) | +---------------------+ +---------------------+ +---------------------+ ^ | API Call/Internal Logic | +---------------------+ | Gemini LLM | +---------------------+ ``` **Detailed Pattern:** 1. **Server Microservice (SSE Provider):** * **Endpoint:** Exposes an HTTP endpoint that serves as the SSE stream. This endpoint should have the correct `Content-Type` header: `text/event-stream`. * **Event Generation:** The server microservice is responsible for generating the events that are pushed to the clients. This is where Gemini comes in. The server might: * **Receive Data:** Receive data from other sources (databases, message queues, other microservices). * **Process with Gemini:** Use the Gemini LLM to process the data. Examples: * **Sentiment Analysis:** Analyze text data and stream the sentiment score. * **Summarization:** Summarize long articles and stream the summaries. * **Translation:** Translate text into different languages and stream the translations. * **Data Enrichment:** Use Gemini to add context or metadata to the data. * **Content Generation:** Generate new content based on input data (e.g., generate product descriptions). * **Format as SSE Events:** Format the processed data into SSE events. Each event consists of: * `event:` (Optional) A string identifying the type of event. * `data:` The actual data payload (usually JSON). Multiple `data:` lines are concatenated. * `id:` (Optional) An event ID. * A blank line (`\n`) to separate events. * **Error Handling:** Implement robust error handling. If Gemini fails or another error occurs, the server should: * Log the error. * Potentially send an error event to the client (e.g., `event: error`, `data: { "message": "Gemini processing failed" }`). * Attempt to recover or gracefully shut down the stream. * **Connection Management:** Handle client connections and disconnections gracefully. Consider implementing a heartbeat mechanism to detect dead connections. * **Rate Limiting:** Implement rate limiting to prevent abuse and ensure the stability of the Gemini LLM and the server. **Example (Python with Flask and `sse_starlette`):** ```python from flask import Flask, Response, request from sse_starlette.sse import EventSourceResponse import google.generativeai as genai import os app = Flask(__name__) # Configure Gemini (replace with your actual API key) genai.configure(api_key=os.environ["GOOGLE_API_KEY"]) model = genai.GenerativeModel('gemini-pro') async def event_stream(): while True: try: # Simulate receiving data (replace with your actual data source) data = "This is a news article about the economy." # Process with Gemini (sentiment analysis) prompt = f"Analyze the sentiment of the following text: {data}" response = model.generate_content(prompt) sentiment = response.text # Extract sentiment from Gemini's response # Format as SSE event event_data = { "article": data, "sentiment": sentiment } yield { "event": "news_update", "data": event_data } await asyncio.sleep(5) # Send updates every 5 seconds except Exception as e: print(f"Error: {e}") yield { "event": "error", "data": {"message": str(e)} } break # Stop the stream on error @app.route('/stream') async def stream(): return EventSourceResponse(event_stream()) if __name__ == '__main__': import asyncio app.run(debug=True, port=5000) ``` 2. **Client Microservice (SSE Consumer):** * **Connect to SSE Endpoint:** Establish a connection to the server's SSE endpoint using an `EventSource` object (in JavaScript) or a similar library in other languages. * **Event Handling:** Register event listeners to handle different types of events received from the server. * **Data Processing:** Process the data received in the events. This might involve: * Updating the UI. * Storing the data in a database. * Triggering other actions. * **Error Handling:** Handle connection errors and errors received in the SSE stream. Implement retry logic to reconnect if the connection is lost. * **Close Connection:** Close the `EventSource` connection when it's no longer needed. **Example (JavaScript):** ```javascript const eventSource = new EventSource('/stream'); // Replace with your server's URL eventSource.addEventListener('news_update', (event) => { const data = JSON.parse(event.data); console.log('Received news update:', data); // Update the UI with the news article and sentiment document.getElementById('article').textContent = data.article; document.getElementById('sentiment').textContent = data.sentiment; }); eventSource.addEventListener('error', (event) => { console.error('SSE error:', event); // Handle the error (e.g., display an error message) }); eventSource.onopen = () => { console.log("SSE connection opened."); }; eventSource.onclose = () => { console.log("SSE connection closed."); }; ``` **Key Considerations and Best Practices:** * **Data Format:** Use a consistent data format (e.g., JSON) for the SSE events. This makes it easier for clients to parse the data. * **Event Types:** Define clear event types to allow clients to handle different types of updates appropriately. * **Error Handling:** Implement comprehensive error handling on both the server and the client. This includes logging errors, sending error events, and implementing retry logic. * **Security:** Secure the SSE endpoint using appropriate authentication and authorization mechanisms. Consider using HTTPS to encrypt the data in transit. * **Scalability:** Design the server microservice to be scalable. Consider using a load balancer to distribute traffic across multiple instances of the server. The Gemini API itself has rate limits, so consider caching or other strategies to minimize API calls. * **Monitoring:** Monitor the performance of the SSE stream and the Gemini API usage. This will help you identify and resolve any issues. * **Idempotency:** If the client is performing actions based on the SSE events, ensure that those actions are idempotent (i.e., they can be performed multiple times without causing unintended side effects). This is important in case of connection interruptions and retries. * **Backpressure:** If the client is unable to process the events as quickly as they are being sent, implement a backpressure mechanism to prevent the client from being overwhelmed. This could involve buffering events on the server or using a flow control mechanism. * **Gemini API Usage:** * **Cost:** Be mindful of the cost of using the Gemini API. Optimize your prompts and data processing to minimize the number of API calls. * **Rate Limits:** Understand and respect the Gemini API rate limits. Implement retry logic with exponential backoff to handle rate limiting errors. * **Prompt Engineering:** Craft your prompts carefully to get the best results from Gemini. Experiment with different prompts to find the ones that work best for your use case. * **Alternatives to SSE:** While SSE is suitable for many real-time scenarios, consider other options like WebSockets or gRPC streams if you need bidirectional communication or more advanced features. **Example Use Cases:** * **Real-time Sentiment Analysis Dashboard:** A server microservice uses Gemini to analyze the sentiment of social media posts and streams the sentiment scores to a client dashboard via SSE. * **Live Translation Service:** A server microservice uses Gemini to translate text in real-time and streams the translations to a client application via SSE. * **AI-Powered News Feed:** A server microservice uses Gemini to summarize news articles and streams the summaries to a client news feed application via SSE. * **Dynamic Product Recommendations:** A server microservice uses Gemini to generate personalized product recommendations based on user behavior and streams the recommendations to a client e-commerce website via SSE. **In summary, this pattern allows you to build real-time microservice applications that leverage the power of Gemini LLM for data processing and enrichment. By using SSE, you can efficiently stream updates to clients, providing a responsive and engaging user experience.**

kickstart-mcp

🚀 Kickstart-mcp é um tutorial para usar o mcp, criando seu próprio servidor/cliente mcp. Nós o guiaremos por cada passo da sua jornada MCP.

BlazeMeter MCP Server

Provides programmatic access to BlazeMeter's performance testing platform through MCP tools. Enables users to retrieve test runs, analyze performance data, view error reports, and manage testing resources via natural language interactions.

mcp-figma

Figma MCP com funcionalidade completa de API

DocuMCP

An MCP server that enables Claude to generate, search, and manage documentation for codebases using vector embeddings and semantic search, providing tools for creating user guides, technical documentation, code explanations, and architectural diagrams.

OPS MCP Server

Uma coleção de ferramentas de monitoramento e inspeção de servidores que fornece utilitários remotos para verificar interfaces de rede, status de serviços e configurações de firewall em servidores.

HWP MCP Server

Um servidor Node.js que implementa o Protocolo de Contexto de Modelo (MCP) para controlar documentos HWP (processador de texto coreano), permitindo que assistentes de IA como o Claude criem e manipulem documentos Hangul.

nREPL MCP Server

Enables interaction with a running Clojure nREPL instance for evaluating Clojure code, inspecting namespaces, and retrieving connection statuses, compatible with MCP clients like Claude Desktop and CLine in VSCode.

hyperliquid-info-mcp

hyperliquid-info-mcp

Interactive Feedback MCP

A Model Context Protocol server that enables AI assistants to request user feedback at critical points during interactions, improving communication and reducing unnecessary tool calls.

PostgreSQL MCP Server (Model Context Protocol)

Servidor MCP baseado em FastMCP para controlar o Postgres

MCP Console Automation Server

Enables AI assistants to fully interact with console applications, monitor output, detect errors, and automate terminal workflows across multiple sessions. Similar to how Playwright works for web browsers but for command-line interfaces.

fpl-server

Servidor MCP para FPL

MCP Tools Suite

Comprehensive toolkit for managing Model Context Protocol (MCP) servers

Giphy MCP Server

This is an auto-generated Multi-Agent Conversation Protocol server that enables interaction with the Giphy API, allowing users to access and use Giphy's GIF services through natural language commands.

YindDao RPA MCP Server

A server implementing the Model Context Protocol (MCP) that connects YindDao AI Power with MCP Hosts, enabling AI to utilize RPA capabilities for workflow automation.

Perplexity MCP Server

An Apify Actor implementing the Model Context Protocol for Perplexity API, enabling AI assistants to search and access information through a standardized interface.

DeepSource MCP Server

Servidor de Protocolo de Contexto do Modelo (MCP) para DeepSource

Quip MCP Server

Servidor de Protocolo de Contexto de Modelo (MCP) para buscar documentos Quip.