Discover Awesome MCP Servers

mcp-gladia

Enables LLMs to transcribe, analyze, and translate audio/video content through Gladia's API.

Tanda Workforce MCP Server

Integrates Tanda Workforce API with AI assistants to manage employee schedules, timesheets, leave requests, clock in/out operations, and workforce analytics through natural language with OAuth2 authentication.

MCP demo (DeepSeek as Client's LLM)

Okay, here's how you can run a minimal client-server demo using the MCP (Message Passing Communication) protocol with the DeepSeek API. This will be a simplified example to illustrate the basic concepts. Keep in mind that a real-world application would likely be more complex. **Important Considerations:** * **DeepSeek API Key:** You'll need a DeepSeek API key to access their models. Make sure you have one and that it's properly configured in your environment. Refer to the DeepSeek documentation for how to obtain and use your API key. * **Python:** This example uses Python. Make sure you have Python 3.6 or later installed. * **Libraries:** You'll need to install the `requests` library for making HTTP requests to the DeepSeek API. You might also want to use `Flask` for a simple server. ```bash pip install requests Flask ``` **Conceptual Overview:** 1. **Client:** The client sends a request (e.g., a text prompt) to the server. 2. **Server:** The server receives the request, calls the DeepSeek API with the prompt, gets the response from DeepSeek, and sends the response back to the client. 3. **MCP (Simplified):** In this example, we'll use HTTP as a simple form of MCP. The client sends an HTTP request, and the server sends an HTTP response. A more robust MCP implementation might use a dedicated messaging queue or other communication mechanisms. **Code Example (Python):** **1. Server (server.py):** ```python from flask import Flask, request, jsonify import requests import os app = Flask(__name__) # Replace with your DeepSeek API key (or set it as an environment variable) DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY") # Get API key from environment variable DEEPSEEK_API_URL = "https://api.deepseek.com/v1/chat/completions" # Replace with the correct DeepSeek API endpoint @app.route('/deepseek', methods=['POST']) def deepseek_request(): try: data = request.get_json() prompt = data.get('prompt') if not prompt: return jsonify({'error': 'No prompt provided'}), 400 # Construct the DeepSeek API request headers = { "Content-Type": "application/json", "Authorization": f"Bearer {DEEPSEEK_API_KEY}" } payload = { "model": "deepseek-chat", # Or the specific model you want to use "messages": [{"role": "user", "content": prompt}], "max_tokens": 150 # Adjust as needed } # Make the request to the DeepSeek API response = requests.post(DEEPSEEK_API_URL, headers=headers, json=payload) response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx) deepseek_data = response.json() # Extract the response from DeepSeek (adjust based on the API's response format) try: answer = deepseek_data['choices'][0]['message']['content'] except (KeyError, IndexError) as e: print(f"Error extracting content from DeepSeek response: {e}") print(f"DeepSeek Response: {deepseek_data}") return jsonify({'error': 'Error processing DeepSeek response'}), 500 return jsonify({'response': answer}) except requests.exceptions.RequestException as e: print(f"Error communicating with DeepSeek API: {e}") return jsonify({'error': f'Error communicating with DeepSeek API: {e}'}), 500 except Exception as e: print(f"An unexpected error occurred: {e}") return jsonify({'error': f'An unexpected error occurred: {e}'}), 500 if __name__ == '__main__': app.run(debug=True, port=5000) # Run the server on port 5000 ``` **2. Client (client.py):** ```python import requests import json SERVER_URL = "http://localhost:5000/deepseek" # Adjust if your server is running elsewhere def send_request(prompt): try: payload = {'prompt': prompt} headers = {'Content-Type': 'application/json'} response = requests.post(SERVER_URL, data=json.dumps(payload), headers=headers) response.raise_for_status() # Raise HTTPError for bad responses data = response.json() return data.get('response') except requests.exceptions.RequestException as e: print(f"Error connecting to the server: {e}") return None except Exception as e: print(f"An unexpected error occurred: {e}") return None if __name__ == '__main__': prompt = "What is the capital of France?" response = send_request(prompt) if response: print(f"DeepSeek's Response: {response}") else: print("Failed to get a response from the server.") ``` **How to Run:** 1. **Set your API Key:** Make sure you have set the `DEEPSEEK_API_KEY` environment variable. For example, in Linux/macOS: ```bash export DEEPSEEK_API_KEY="YOUR_DEEPSEEK_API_KEY" ``` Or in Windows: ```bash set DEEPSEEK_API_KEY=YOUR_DEEPSEEK_API_KEY ``` 2. **Start the Server:** Open a terminal and run: ```bash python server.py ``` The server should start and listen on port 5000. 3. **Run the Client:** Open another terminal and run: ```bash python client.py ``` The client will send the prompt to the server, the server will call the DeepSeek API, and the client will print the response. **Explanation:** * **Server (server.py):** * Uses Flask to create a simple web server. * The `/deepseek` route handles POST requests. * It extracts the prompt from the request body. * It constructs a request to the DeepSeek API, including your API key and the prompt. * It sends the request to the DeepSeek API using the `requests` library. * It parses the response from DeepSeek and extracts the generated text. **Important:** The exact structure of the DeepSeek API response may vary, so you'll need to adjust the code accordingly. Refer to the DeepSeek API documentation. * It sends the response back to the client as a JSON object. * Includes error handling for API request failures and other potential issues. * **Client (client.py):** * Sends a POST request to the server's `/deepseek` endpoint with the prompt in the request body. * Receives the response from the server and prints the generated text. * Includes basic error handling. **Important Notes and Improvements:** * **Error Handling:** The error handling in this example is basic. You should add more robust error handling to catch potential issues, such as network errors, API errors, and invalid responses. * **API Key Security:** Storing your API key directly in the code is not recommended for production environments. Use environment variables or a more secure method for managing your API key. The example uses `os.environ.get("DEEPSEEK_API_KEY")` which is a better practice. * **Asynchronous Communication:** For more complex applications, consider using asynchronous communication (e.g., `asyncio` in Python) to improve performance and responsiveness. * **MCP Implementation:** This example uses HTTP as a simplified form of MCP. For a more robust MCP implementation, you could use a message queue (e.g., RabbitMQ, Kafka) or a dedicated messaging library. * **DeepSeek API Documentation:** Always refer to the official DeepSeek API documentation for the most up-to-date information on API endpoints, request parameters, and response formats. * **Model Selection:** The `model` parameter in the DeepSeek API request specifies which model to use. Choose the appropriate model based on your needs. * **Token Limits:** Be aware of the token limits for the DeepSeek API. The `max_tokens` parameter controls the maximum number of tokens in the generated response. * **Rate Limiting:** The DeepSeek API may have rate limits. Implement appropriate rate limiting in your code to avoid exceeding the limits. * **Flask Debug Mode:** `debug=True` in `app.run()` is useful for development but should be disabled in production. This example provides a starting point for building a client-server application using the DeepSeek API. Remember to adapt the code to your specific requirements and to consult the DeepSeek API documentation for the most accurate information.

mcp-local-redes

Local MCP server that exposes fleet telemetry queries as tools for language models, enabling natural language questions about vehicle positions, trips, and alerts. Runs on the operator's machine and returns aggregated results from a SQLite database.

MCP Server - Placeholder Implementation

An MCP server implementation in Python with placeholder tools, deployable to Azure Web App via GitHub Actions. Supports STDIO, HTTP REST, and WebSocket interfaces.

mcp-ip-api

Provides IP geolocation lookups via ip-api.com, including single and batch queries up to 100 IPs.

codex-in-claude

Call OpenAI Codex from Claude Code for independent second opinions, structured code review, and delegated coding tasks through a FastMCP plugin that drives the codex CLI safely.

figma-bridge

基于MCP协议的工具，用于从Figma获取设计节点数据并转换为结构化DSL，辅助生成Vue 3 / React / HTML组件代码。

@pipeworx/congressional-documents

Full-text search and retrieval over official congressional documents (hearings, committee reports, Congressional Record) with citations and govinfo.gov links, designed for grounding AI answers in the official record.

Freshdesk MCP Server

Enables interaction with Freshdesk API v2 to manage support tickets, contacts, agents, companies, and conversations with built-in authentication, rate limiting, and error handling.

blender-mcp-2.79

Enables Claude AI to control Blender 2.79 for 3D modeling, scene creation, and manipulation through the Model Context Protocol, with legacy compatibility for older Blender versions.

MCP Router

Automatically selects the optimal LLM model for each task in Cursor IDE by analyzing query complexity, task type, and applying customizable routing strategies across 17 different AI models.

Terminal SSH MCP Server

MCP server that enables SSH access and terminal commands for Railway containers and local shell execution.

Assert

Run real Playwright E2E tests from your AI coding agent.

MCP-123

A lightweight implementation that provides the simplest way to set up an MCP server and client, requiring just two lines of code to create a fully functional system.

metabase-mcp

Connects AI assistants to Metabase for database queries, SQL execution, dashboard management, and analytics workflows via natural language.

remote-mcp-server-authless

This is a stateless remote MCP server deployed on Cloudflare Workers without authentication, allowing users to register custom tools and connect to MCP clients such as Cloudflare AI Playground or Claude Desktop.

Sourcify Context Server

A simple notes MCP server that enables creating, listing, and summarizing text notes via resources, tools, and prompts.

ltchiptool-mcp

Enables chip-level firmware extraction and analysis for BK7231 family IoT devices via UART, supporting flash dumping, decryption, and partition extraction.

idnow-mcp-server

An MCP server that lets LLM agents operate the IDnow Trust Platform sandbox to list verification flows, create sessions, check sessions, and get session details.

Oracle HCM Cloud MCP Server by CData

Oracle HCM Cloud MCP Server by CData

ministic-fishstick

Minimal high-performance MCP server for semantic code indexing and vector search using Bun, SQLite, and Tree-Sitter. It enables AI agents to index, search, and manage codebases via tools like code_index_search and code_index_start.

Weather MCP Server

Enables asking natural language weather questions; an LLM agent selects the appropriate live weather API tool and returns an HTML-formatted answer.

PubMed MCP Server

Provides structured PubMed literature data for LLM agents, supporting search, caching, and open-access full-text downloads via the MCP protocol.

newrelic-mcp-server

Provides New Relic observability tools for AI assistants, enabling discovery, data access, alerting, incident response, and performance analytics via natural language queries.

trafikkmeldinger-mcp

Enables querying Norwegian traffic messages (roadworks, closures, detours) from Statens vegvesen, filtered by route and time window. Supports both current and future travel times, with tools for route-based and general searches.

MCPizza

An MCP server that allows AI assistants to order Domino's Pizza through an unofficial API, with features for store location, menu browsing, and order management.

Local FAISS MCP Server

Provides local vector database functionality using FAISS for document ingestion, semantic search, and Retrieval-Augmented Generation (RAG) applications with persistent storage and customizable embedding models.

Multi-Capability Proxy Server

A Flask-based server that hosts multiple tools, each exposing functionalities by calling external REST APIs through a unified interface.

spar-agent

Enables developers to compare their code predictions against AI-generated implementations, log misconceptions, and receive spaced-repetition learning feedback to guide their understanding of gaps.