Discover Awesome MCP Servers

Google Health ChatGPT MCP

Self-hosted MCP server that provides read-only access to Google Health API v4, enabling analysis of personal health data via OpenAI Responses API or ChatGPT.

Self-Hosted Supabase MCP Server

Enables developers to interact with self-hosted Supabase instances, providing database introspection, migration management, auth user operations, storage management, and TypeScript type generation directly from MCP-compatible development environments.

@container-inc/mcp

Server MCP untuk penerapan otomatis ke Container Inc.

Better Playwright MCP

Token-efficient browser automation MCP server using Playwright, with getOutline and searchSnapshot to save ~95% tokens compared to full snapshots.

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.

Zoho Mail MCP Server

Enables AI assistants to manage Zoho Mail accounts, including sending/receiving emails, folder and label management, organization administration, and productivity tools like tasks and notes.

file-extractor-mcp

Enables file extraction, organization, and GitHub repository management through MCP tools, allowing AI agents to copy/move files, delete repositories, and automate workflows.

Segundo Cérebro

Self-hosted personal knowledge graph running on Cloudflare, connecting to Claude as an MCP server for capturing atomic concepts and cross-domain analogies.

HWP RAG MCP

Enables searching local Korean HWP/HWPX documents via Codex or Claude Code by indexing them with a free multilingual embedding model, keeping documents and indexes locally without requiring an API key.

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.

Gov Data MCP

MCP server with 562 tools accessing 114 government data APIs covering economic, health, education, energy, and more from federal, state, and international sources.

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.

FastAPI MCP Demo Server

A demonstration MCP server built with FastAPI that provides basic mathematical operations and greeting services. Integrates with Gemini CLI to showcase MCP protocol implementation with simple REST endpoints.

Kundlit Vedic Astrology

Hosted Streamable HTTP MCP server for Vedic astrology: panchang, kundali (birth chart), matchmaking, dashas, doshas, muhurta and 16 tools computed by a precision astronomy engine.

claude-desktop-mcp

A fake MCP server with 108 themed tools for testing Claude Desktop's handling of large toolsets and Amazon Bedrock AgentCore Gateway integration.

MCP Terminal

Sebuah server yang memungkinkan asisten AI untuk menjalankan perintah terminal dan mengambil output melalui Model Context Protocol (MCP).

AgentVault MCP Server

Enables AI agents to manage secrets and credentials from a secure vault via MCP tools over stdio.

hoppscotch-mcp

Enables automation of Hoppscotch team collections, including OpenAPI sync, code-based endpoint analysis, and safe mutation with dry-run and backup.

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 (Message Channel Protocol) clients and servers, leveraging the Gemini LLM (Large Language Model). This pattern focuses on how to integrate Gemini for tasks like message processing, content generation, or intelligent routing within the MCP framework. **Core Concepts:** * **SSE (Server-Sent Events):** A unidirectional communication protocol where the server pushes data updates to the client over a single HTTP connection. It's ideal for real-time updates and streaming data. * **MCP (Message Channel Protocol):** A protocol for exchanging messages between different components of a system. It often involves defining message formats, routing rules, and error handling. In this context, we're assuming a custom or simplified MCP tailored to your specific needs. * **Gemini LLM:** Google's Large Language Model, used here for tasks like understanding message content, generating responses, or making decisions based on the message data. **Architecture Overview:** ``` [Client (MCP over SSE)] <--SSE--> [MCP Server] <--Internal Communication--> [Gemini LLM Integration] ``` **Detailed Breakdown:** 1. **Client (MCP over SSE):** * **Responsibilities:** * Establishes an SSE connection to the MCP Server. * Encodes messages according to the MCP specification. This might involve defining message types, data structures (e.g., JSON), and headers. * Sends messages to the server (typically via HTTP requests that trigger server-sent events). The specific mechanism depends on your MCP design. It might be a simple HTTP POST request with the message in the body. * Receives SSE events from the server. * Decodes the SSE event data into MCP messages. * Handles different message types and takes appropriate actions (e.g., displaying data, updating the UI, triggering other events). * Handles connection errors and retries. * **Example (Conceptual):** ```python import sseclient import requests import json def send_message(message_type, data): url = "http://your-mcp-server/send" # Endpoint to send messages headers = {'Content-Type': 'application/json'} payload = {'type': message_type, 'data': data} response = requests.post(url, headers=headers, data=json.dumps(payload)) return response.status_code def listen_for_events(): url = "http://your-mcp-server/events" # SSE endpoint response = requests.get(url, stream=True) client = sseclient.SSEClient(response) for event in client.events(): try: message = json.loads(event.data) message_type = message.get('type') message_data = message.get('data') if message_type == "update_data": print(f"Received data update: {message_data}") # Update UI or perform other actions elif message_type == "gemini_response": print(f"Gemini response: {message_data}") # Display the response else: print(f"Unknown message type: {message_type}") except json.JSONDecodeError: print(f"Error decoding JSON: {event.data}") except Exception as e: print(f"Error processing event: {e}") # Example usage: send_message("user_query", {"query": "What is the capital of France?"}) listen_for_events() ``` 2. **MCP Server:** * **Responsibilities:** * Accepts incoming HTTP requests to send messages (e.g., via POST). * Validates incoming messages according to the MCP specification. * Routes messages to the appropriate internal components or services. This is a crucial part of the MCP. * Integrates with Gemini LLM for specific message types or processing needs. * Generates SSE events and pushes them to connected clients. * Manages SSE connections (e.g., keeping track of connected clients, handling disconnections). * Handles errors and logging. * **Gemini Integration Points:** * **Message Understanding:** Use Gemini to analyze the content of a message and extract key information or intent. This can be used for routing or processing the message. For example, if a message contains a user query, Gemini can identify the topic and keywords. * **Content Generation:** Use Gemini to generate responses to user queries or to create new content based on the message data. For example, if a message requests a summary of a document, Gemini can generate the summary. * **Intelligent Routing:** Use Gemini to determine the best destination for a message based on its content and context. This can be used to route messages to different services or components within the system. * **Data Enrichment:** Use Gemini to add additional information to a message before it is sent to the client. For example, if a message contains a location, Gemini can add weather information for that location. * **Example (Conceptual - Python with Flask):** ```python from flask import Flask, request, Response, jsonify import json import time import threading # Assuming you have a Gemini API client set up # from google.generativeai import GenerativeModel # gemini_model = GenerativeModel('gemini-1.5-pro') app = Flask(__name__) clients = [] # List to store connected clients def generate_sse_event(message_type, data): message = json.dumps({'type': message_type, 'data': data}) return f"data: {message}\n\n" def event_stream(): while True: for client in clients: if client['queue']: message = client['queue'].pop(0) yield generate_sse_event(message['type'], message['data']) time.sleep(0.1) # Adjust as needed @app.route('/events') def events(): def stream(): client_info = {'queue': []} clients.append(client_info) try: yield from event_stream() finally: clients.remove(client_info) return Response(stream(), mimetype='text/event-stream') @app.route('/send', methods=['POST']) def send(): try: data = request.get_json() message_type = data.get('type') message_data = data.get('data') if not message_type or not message_data: return jsonify({'error': 'Invalid message format'}), 400 # Example: Gemini integration for user queries if message_type == "user_query": query = message_data.get('query') if query: # response = gemini_model.generate_content(query) # gemini_response = response.text gemini_response = f"Simulated Gemini response to: {query}" # Replace with actual Gemini call # Send the Gemini response back to the client for client in clients: client['queue'].append({'type': 'gemini_response', 'data': gemini_response}) # Example: Simple echo back to all clients for client in clients: client['queue'].append({'type': message_type, 'data': message_data}) return jsonify({'status': 'Message processed'}), 200 except Exception as e: print(f"Error processing message: {e}") return jsonify({'error': str(e)}), 500 if __name__ == '__main__': app.run(debug=True, port=5000) ``` 3. **Gemini LLM Integration:** * **Responsibilities:** * Receives requests from the MCP Server. * Processes the requests using the Gemini LLM API. This involves sending prompts to Gemini and receiving responses. * Returns the results to the MCP Server. * Handles API authentication and rate limiting. * Implements error handling and retry logic. * **Key Considerations:** * **API Authentication:** Securely store and manage your Gemini API key. Avoid hardcoding it in your code. Use environment variables or a secrets management system. * **Prompt Engineering:** Craft effective prompts to get the desired results from Gemini. Experiment with different prompts to optimize performance. Consider using techniques like few-shot learning or chain-of-thought prompting. * **Rate Limiting:** Be aware of the Gemini API rate limits and implement appropriate throttling mechanisms to avoid exceeding them. * **Error Handling:** Handle potential errors from the Gemini API, such as network errors, API errors, and invalid requests. Implement retry logic to handle transient errors. * **Cost Optimization:** Monitor your Gemini API usage and costs. Optimize your prompts and requests to minimize the number of tokens used. Consider using caching to avoid making redundant API calls. * **Data Privacy:** Be mindful of data privacy regulations when sending data to the Gemini API. Avoid sending sensitive or personally identifiable information unless absolutely necessary. **Working Pattern Summary:** 1. **Client Sends Message:** The client encodes an MCP message and sends it to the MCP Server via an HTTP POST request. 2. **Server Receives and Validates:** The MCP Server receives the message, validates it against the MCP specification, and determines the appropriate action. 3. **Gemini Integration (Conditional):** If the message type requires Gemini processing (e.g., a user query), the server sends a request to the Gemini LLM integration component. 4. **Gemini Processes Request:** The Gemini LLM integration component sends a prompt to the Gemini API, receives the response, and returns the result to the MCP Server. 5. **Server Generates SSE Event:** The MCP Server generates an SSE event containing the processed message (potentially including the Gemini response) and pushes it to all connected clients (or a subset of clients, depending on your routing logic). 6. **Client Receives and Decodes:** The client receives the SSE event, decodes the message, and takes appropriate action (e.g., updating the UI, displaying the Gemini response). **Example Scenario: Real-Time Chat with Gemini-Powered Assistance** * **Client:** A chat application. * **MCP Server:** Handles chat messages and integrates with Gemini. * **Gemini:** Provides intelligent assistance, such as answering questions, summarizing conversations, or suggesting responses. 1. **User sends a message:** The client sends a chat message to the MCP Server with `message_type = "chat_message"` and `data = {"text": "What is the weather like in London?"}`. 2. **Server receives the message:** The server receives the message and determines that it's a chat message. 3. **Gemini Integration:** The server sends a request to Gemini with a prompt like: `"Answer the following question: What is the weather like in London?"`. 4. **Gemini responds:** Gemini returns the weather information for London. 5. **Server generates SSE events:** The server generates two SSE events: * `message_type = "chat_message", data = {"user": "user1", "text": "What is the weather like in London?"}` (to display the original message) * `message_type = "gemini_response", data = {"text": "The weather in London is currently sunny with a temperature of 20 degrees Celsius."}` (to display the Gemini response) 6. **Client receives events:** The client receives both SSE events and updates the chat UI accordingly. **Key Considerations for Implementation:** * **Scalability:** Consider using a message queue (e.g., RabbitMQ, Kafka) to decouple the MCP Server from the Gemini LLM integration component. This can improve scalability and resilience. * **Error Handling:** Implement robust error handling throughout the system. Log errors and provide informative error messages to the client. * **Security:** Secure your SSE connections using HTTPS. Implement authentication and authorization to protect your MCP endpoints. * **Monitoring:** Monitor the performance of your system and identify potential bottlenecks. Use metrics to track the number of messages processed, the latency of Gemini API calls, and the number of connected clients. * **MCP Design:** Carefully design your MCP to meet your specific needs. Define clear message types, data structures, and routing rules. This detailed breakdown provides a solid foundation for building an SSE-based MCP client and server that leverages the power of Gemini LLM. Remember to adapt this pattern to your specific requirements and constraints. Good luck!

mcp-estat-japan

Enables querying Japanese government statistics from e-Stat, including metadata, data observations, and catalog browsing.

smartlead-cli

MCP server for managing cold email campaigns, leads, email accounts, sequences, analytics, webhooks, and client sub-accounts via the Smartlead API.

mcp-server-yeelight-lan

Enables control of Yeelight smart lights over local LAN, supporting on/off, brightness, color, temperature, and auto discovery.

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.

wikijs-mcp

MCP server for accessing Wiki.js through its GraphQL API, enabling page management, search, tags, and system info operations.

Phrase MCP Server

Use Phrase APIs from any MCP client (Claude, Cursor, etc.) with ready-to-use tools for Phrase Strings, Phrase TMS, and Connectors.

AnyDocs MCP Server

Transforms any website's documentation into an MCP-compatible interactive knowledge base with universal scraping, advanced search, and AI-powered tools. Supports GitBook, Notion, Confluence, and custom documentation platforms with real-time synchronization.

Dynamic Reincarnation Story

Enables interactive reincarnation storytelling where users choose their path after death, becoming characters like a vengeful spirit, Bilbo Baggins, or Monkey D. Luffy. Features dynamic narrative generation with personalized story paths based on user choices and soul-searching questions.

iroha for Notion

Persists Claude Code sessions to Notion as team memory, enabling queryable recall of decisions, work state, and project architecture.