Discover Awesome MCP Servers

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 (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!

FreeCrawl MCP Server

Enables web scraping and document processing with JavaScript execution, anti-detection measures, batch processing, and structured data extraction. Supports multiple formats including markdown, HTML, screenshots, and handles PDFs with OCR capabilities.

Accessibility MCP Server

Provides comprehensive accessibility auditing tools for websites using axe-core, Lighthouse CLI, and WAVE API. Returns deterministic, WCAG-mapped results with selectors and DOM context for remediation.

medwriter-mcp

Medical Writer's AI Toolkit — 33 expert prompts for pharma medical writing as MCP tools

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.

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

Menyediakan akses ke dokumen Feishu (Lark) untuk alat pengkodean berbasis AI seperti Cursor, Windsurf, dan Cline berdasarkan implementasi Model Context Protocol.

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.

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.

cisco-secure-access-mcp

A community MCP server for Cisco Secure Access that exposes the Secure Access REST API to AI clients as a curated catalog of tools for Admin, Deployments, Investigate, Policies, and Reports.

MCP-openproject

MCP-openproject

Puch AI MCP Starter

A starter template for creating MCP servers compatible with Puch AI, featuring built-in tools for job searching and analysis, plus basic image processing capabilities. Includes authentication and deployment guidance for extending Puch AI with custom tools.

Time Tools MCP Server

A Model Context Protocol server for time manipulation tasks, enabling AI models to get the current date/time and calculate duration between timestamps.

Inspectra

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

Jupyter MCP Server

Memungkinkan interaksi dengan buku catatan Jupyter melalui Protokol Konteks Model, mendukung eksekusi kode dan penyisipan markdown di dalam lingkungan 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.