Discover Awesome MCP Servers

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.

WhatsApp MCP Server 🚀

Servidor MCP do WhatsApp

fpl-server

Servidor MCP para FPL

Salesforce Einstein MCP Server by CData

This read-only MCP Server allows you to connect to Salesforce Einstein data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

Socket MCP Server

A Model Context Protocol (MCP) server for Socket integration, allowing AI assistants to efficiently check dependency vulnerability scores and security information.

mcp-server-weather-test

teste-de-clima-mcp-servidor

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.

mcp-declarative-java-sdk-examples

MCP Server Examples: Built Using Annotation-driven MCP Java SDK

FhirMCP

Enables LLMs to securely interact with FHIR healthcare servers and HL7 terminology services. Provides comprehensive healthcare data operations with built-in PHI protection, audit logging, and SMART on FHIR authentication.

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.

MarketAuxMcpServer

A MCP Server Implementation that integrates the Marketaux api providing search based on entity, countries, industries, symbols etc.

BloodHound-MCP

BloodHound-MCP-AI é uma integração que conecta o BloodHound com a IA através do Protocolo de Contexto de Modelo (Model Context Protocol), permitindo que profissionais de segurança analisem caminhos de ataque do Active Directory usando linguagem natural em vez de consultas Cypher complexas.

weather-mcp

Returns the current and recent weather data using city name or pincode(india). Using tomorrow.io api

Claude MCP Server Ecosystem

A production-ready MCP server ecosystem providing Claude AI with 150+ specialized tools across enhanced memory, data analytics, security, design, and infrastructure domains with PostgreSQL, Redis, Qdrant, and Docker orchestration.

MCP Demo

Servidor MCP do Slack com Python

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

MaxKB

💬 MaxKB é um chatbot RAG pronto para uso que apresenta um fluxo de trabalho robusto e capacidades de uso de ferramentas MCP. Ele suporta uma ampla gama de modelos de linguagem grandes (LLMs) convencionais, incluindo DeepSeek-R1, Llama 3.3, OpenAI, entre outros.

Celestial Position MCP Server

Provides altitude-azimuth coordinates for celestial objects including planets, over 117,000 stars, and 14,000 deep sky objects based on system time and configurable location.

pumpswap-mcp

pumpswap-mcp

Amazon Nova Reel MCP Server

An MCP server for generating videos through Amazon Nova Reel 1.1 using AWS Bedrock, providing asynchronous video generation with comprehensive prompting guidelines and multiple transport methods.

Gemini MCP Server

Integrates Google Gemini AI into Warp terminal workflows through three focused tools: single-turn chat for quick questions, multi-turn conversations with context preservation, and AI-powered code analysis with bug detection and optimization suggestions.

Tavily Web Search MCP Server

Enables web search capabilities through the Tavily API, allowing users to search the internet for information using natural language queries. Serves as a demonstration and educational project for building MCP servers with external API integrations.

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.

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.**