Discover Awesome MCP Servers

Inspectra

Enables hybrid code audits using MCP tools across 12 domains, producing structured, scored, and actionable code quality reports.

Jupyter MCP Server

Permite a interação com notebooks Jupyter através do Protocolo de Contexto do Modelo, suportando a execução de código e a inserção de markdown em ambientes JupyterLab.

MCP Weather & Files AI Server

An advanced Model Context Protocol server that integrates real-time weather data, local file system navigation, and geographic information with AI-powered analysis tools. It enables users to perform complex data evaluations and manage files while accessing live climatic and demographic data through compatible MCP clients.

Gold Standard Apology MCP

Provides guidelines for writing proper apologies based on the situation, relationship, and severity. Returns structured prompts that help LLMs generate sincere and appropriate apology letters in Korean.

Supabase MCP Server

Connects AI assistants to Supabase projects, enabling them to manage tables, query data, deploy Edge Functions, handle migrations, and access project resources through natural language commands.

@margint-ai/mcp

Enables querying Margint per-customer AI margins and costs from MCP clients. Provides tools to list customers, drill into costs, check budgets, and view workspace-wide cost breakdowns.

jpzip MCP server

Enables to look up Japanese postal codes, convert zipcodes to addresses, search addresses by query, and list cities in a prefecture using the jpzip dataset.

JSON MCP Boilerplate

A starter template for building MCP (Model Context Protocol) servers with TypeScript support. Provides a clean foundation with example tools, resources, and prompts for creating custom integrations with Claude, Cursor, or other MCP-compatible AI assistants.

Attio MCP Server

Enables AI assistants to interact with Attio CRM through natural language, providing complete access to companies, people, deals, tasks, lists, notes, and records with advanced search, batch operations, and relationship management.

thermal-mcp-server

A physics engine for liquid-cooled GPU systems, exposed as an AI-callable MCP server. Enables thermal analysis, coolant comparison, flow optimization, and rack-level sizing via natural language queries.

vSphere MCP Server

Enables AI agents to manage VMware vSphere virtual infrastructure through comprehensive operations including VM power control, snapshot management, resource monitoring, performance analytics, and bulk operations with built-in safety confirmations for destructive actions.

MANIT ERP MCP Server

Simple MCP server that exposes a tool to fetch student result/CGPA data from MANIT ERP APIs.

negative-results-mcp

Negative results intelligence for drug discovery: inactive compounds, failed selectivity panels, terminated clinical trials, failed CRISPR screens, antibody developability failures, and more — each result carrying full provenance (source database, DOI/PMID, license)

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.

Garmin Connect MCP Server

Connects Garmin Connect data to MCP-compatible clients, providing access to fitness activities, health metrics, and training plans. It supports advanced features like headless 2FA and automated MFA retrieval to enable seamless health data interaction through natural language.

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

MCP Filesystem Server

Um servidor de Protocolo de Contexto de Modelo que oferece interação segura e inteligente com arquivos e sistemas de arquivos, proporcionando gerenciamento de contexto inteligente e operações com uso eficiente de tokens para trabalhar com arquivos grandes e estruturas de diretórios complexas.

Shared Memory MCP Server

Provides a shared context layer for AI agent teams to improve token efficiency through context deduplication and incremental state sharing. It enables multiple agents to coordinate tasks, share real-time discoveries, and manage dependencies while significantly reducing redundant data transmission.

MCP Docker Server

Enables secure Docker command execution from isolated environments like containers through MCP protocol. Provides tools for managing Docker containers, images, and Docker Compose services with security validation and async operation support.

Remote MCP Server

A deployable Model Context Protocol server for Cloudflare Workers that allows users to create custom AI tools without authentication requirements and connect them to Cloudflare AI Playground or Claude Desktop.

mcp-mempool-space

MCP server for Bitcoin block explorer and mempool/fee statistics, providing tools to query fees, mempool stats, blocks, transactions, addresses, hashrate, and mining pools.

erpnext-server

Este é um servidor MCP baseado em TypeScript que fornece integração com a API ERPNext/Frappe. Ele permite que assistentes de IA interajam com os dados e funcionalidades do ERPNext através do Protocolo de Contexto de Modelo (Model Context Protocol).

odigo-elastic-s2l-mcp

Connects LLMs to Elasticsearch with a Semantic-to-Lexical layer that translates technical field names into business knowledge, enabling autonomous querying without hardcoded domain logic.

MySQL MCP Server

Enables secure interaction with MySQL databases through listing tables, reading data, and executing SQL queries with proper error handling and controlled access.

MCP Databases Server

Enables LLMs and agents to interact with relational databases (SQL Server, MySQL, PostgreSQL) through MCP tools. Supports executing queries, inserting records, listing tables, and exposing database schemas with secure credential management.

Feishu Integration Server

Permite o acesso a documentos do Feishu (Lark) para ferramentas de codificação orientadas por IA, como Cursor, Windsurf e Cline, com base na implementação do Protocolo de Contexto de Modelo.

agriculture-mcp-server

MCP server for agriculture and farming data. 8 tools: soil conditions (temperature, moisture), crop weather forecasts, historical climate data (NASA POWER, since 1981), global agriculture statistics (World Bank, 20+ indicators), and food product database (Open Food Facts, 3M+ products). All APIs free, no keys required.