Discover Awesome MCP Servers

ansys-aedt-mcp

Enables AI agents to control Ansys Electronics Desktop (HFSS, Maxwell, Q3D, etc.) using MCP tools for simulation automation.

MCP DeepSeek 演示项目

Okay, here's a minimal example of using DeepSeek (assuming you mean DeepSeek LLM or a similar model) combined with MCP (MicroConfig Protocol) in a client-server scenario. This is a simplified illustration and would need adaptation based on your specific DeepSeek model and MCP implementation. **Conceptual Overview:** * **MCP (MicroConfig Protocol):** A lightweight protocol for configuration management. In this example, we'll use it to send a prompt to the DeepSeek server and receive the generated text. We'll assume a simple key-value pair structure for MCP messages. * **DeepSeek Server:** A server that hosts the DeepSeek LLM. It receives prompts via MCP, generates text, and sends the response back via MCP. * **Client:** A client that sends a prompt to the DeepSeek server via MCP and displays the response. **Simplified Code Examples (Python):** **1. DeepSeek Server (server.py):** ```python import socket import json # Assuming you have a way to interact with your DeepSeek model # (e.g., using a DeepSeek API or a local model) # Replace this with your actual DeepSeek interaction code. def generate_text_with_deepseek(prompt): """ Placeholder for DeepSeek model interaction. Replace with your actual DeepSeek API call or model inference. """ # Simulate DeepSeek response if "translate" in prompt.lower(): response = "Hola mundo!" # Example Spanish translation else: response = f"DeepSeek says: {prompt}" return response def handle_client(conn, addr): print(f"Connected by {addr}") try: while True: data = conn.recv(1024) # Receive up to 1024 bytes if not data: break try: # MCP: Assume JSON-based key-value pairs message = json.loads(data.decode('utf-8')) prompt = message.get("prompt") if prompt: generated_text = generate_text_with_deepseek(prompt) response_message = {"response": generated_text} conn.sendall(json.dumps(response_message).encode('utf-8')) else: error_message = {"error": "No prompt provided"} conn.sendall(json.dumps(error_message).encode('utf-8')) except json.JSONDecodeError: error_message = {"error": "Invalid JSON format"} conn.sendall(json.dumps(error_message).encode('utf-8')) except Exception as e: error_message = {"error": f"Server error: {str(e)}"} conn.sendall(json.dumps(error_message).encode('utf-8')) except ConnectionResetError: print(f"Connection reset by {addr}") finally: conn.close() print(f"Connection closed with {addr}") def start_server(): HOST = "127.0.0.1" # Standard loopback interface address (localhost) PORT = 65432 # Port to listen on (non-privileged ports are > 1023) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Listening on {HOST}:{PORT}") while True: conn, addr = s.accept() handle_client(conn, addr) if __name__ == "__main__": start_server() ``` **2. Client (client.py):** ```python import socket import json HOST = "127.0.0.1" # The server's hostname or IP address PORT = 65432 # The port used by the server def send_prompt(prompt): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) message = {"prompt": prompt} s.sendall(json.dumps(message).encode('utf-8')) data = s.recv(1024) response = json.loads(data.decode('utf-8')) print(f"Received: {response}") except ConnectionRefusedError: print("Connection refused. Is the server running?") except Exception as e: print(f"Error: {e}") if __name__ == "__main__": user_prompt = input("Enter a prompt for DeepSeek: ") send_prompt(user_prompt) ``` **How to Run:** 1. **Install Dependencies:** You'll need Python installed. No external libraries are strictly required for this minimal example, but you'll need to install the DeepSeek API client library if you're using a remote DeepSeek service. 2. **Replace Placeholder:** In `server.py`, **replace the `generate_text_with_deepseek` function with your actual DeepSeek model interaction code.** This is the crucial part where you integrate with the DeepSeek LLM. This will likely involve using an API key, setting model parameters, and handling the API response. 3. **Start the Server:** Run `python server.py` in a terminal. 4. **Run the Client:** Run `python client.py` in another terminal. The client will prompt you to enter text. Type a prompt and press Enter. The client will send the prompt to the server, the server will process it with DeepSeek, and the client will display the response. **Explanation:** * **MCP (Simplified):** The code uses JSON to encode and decode messages between the client and server. This is a simple form of MCP. A real MCP implementation might have more sophisticated features like versioning, error handling, and data validation. * **Sockets:** The code uses Python's `socket` module for network communication. The server listens for incoming connections, and the client connects to the server. * **Error Handling:** The code includes basic error handling for connection errors, JSON parsing errors, and server-side exceptions. * **DeepSeek Integration (Placeholder):** The `generate_text_with_deepseek` function is a placeholder. You **must** replace it with your actual DeepSeek API call or model inference code. This is the core of the integration. **Important Considerations:** * **DeepSeek API/Model:** This example assumes you have access to a DeepSeek LLM, either through an API or a local model. You'll need to obtain API credentials or set up your local model environment. * **Security:** This is a very basic example and does not include any security measures. In a production environment, you would need to implement authentication, authorization, and encryption. * **Scalability:** This example is not designed for high scalability. For production use, you would need to consider using a more robust server architecture and load balancing. * **MCP Implementation:** This example uses a very simple JSON-based MCP. A real MCP implementation might use a more efficient binary format or a more sophisticated protocol. * **Error Handling:** The error handling is basic. You should add more robust error handling and logging for production use. **Example Interaction:** 1. **Run `server.py`** 2. **Run `client.py`** 3. **Client Prompt:** `Translate "Hello world!" to Spanish` 4. **Client Output:** `Received: {'response': 'Hola mundo!'}` This minimal example provides a starting point for integrating DeepSeek with MCP. You'll need to adapt it to your specific requirements and environment. Remember to replace the placeholder code with your actual DeepSeek interaction logic. Good luck!

mcp-jokes

Enables searching jokes by keyword and retrieving joke categories using the free JokeAPI v2, with no authentication required.

codecks-mcp

A TypeScript MCP server for Codecks project management that provides over 32 tools to manage cards, decks, milestones, and PM workflows. It enables users to perform actions like creating cards, tracking activity, and managing project conversations through the Model Context Protocol.

vCluster YAML MCP Server

Enables AI assistants to query, validate, and create vCluster YAML configurations directly from GitHub, supporting version-specific queries and automatic validation.

vet-mcp

vet-mcp

Fathom MCP Server

Enables querying meeting transcripts, summaries, and action items from Fathom directly in your MCP-compatible AI assistant, eliminating context switching while coding.

OCI Core Services FastMCP Server

A dedicated server for Oracle Cloud Infrastructure (OCI) Core Services that enables management of compute instances and network operations with LLM-friendly structured responses.

Singapore News MCP Server

Provides real-time news feeds from major Singapore news sources including The Straits Times, Business Times, and Channel News Asia. Delivers live news updates through Server-Sent Events for up-to-date information access.

cross-claude-mcp

A message bus that enables AI assistants (Claude, ChatGPT, Gemini, Perplexity) to communicate via shared channels using MCP or REST APIs.

astral-bridge

Connects QQ via NapCat OneBot v11 to an Astral Code app-server, exposing MCP tools for sending messages, files, images, and fetching conversation history.

Dewey

Enables searching and researching document collections through hybrid semantic search and agentic research queries with grounded, cited answers. It allows users to list collections, scan document sections, and retrieve full Markdown content via MCP-compatible agents.

appsmith-mcp

An MCP server that enables AI agents to build and edit Appsmith apps by driving the browser editor via WebDriver BiDi and Redux store manipulation.

perseus

MCP server with 24 tools for live workspace state resolution. Pre-resolves git status, service health, file queries, memory federation, and multi-agent coordination into markdown before the AI sees it. Single-file Python (pyyaml only), MIT. Serves over stdio and SSE. Published as io.github.tcconnally/perseus on the MCP Registry.

MCP Troubleshooter

A specialized diagnostic framework that enables AI models to self-diagnose and fix MCP-related issues by analyzing logs, validating configurations, testing connections, and implementing solutions.

jobjourney-claude-plugin

An MCP server that enables AI-assisted job search workflows including job discovery, application tracking, resume evaluation, and cover letter generation, with support for multiple job sources and scheduled scraping.

ladder-mcp

Windows-first MCP bridge for Kimi Code CLI, exposing code analysis, editing, sessions, and diagnostics as tools for AI agents.

mcp-open-fec

Access Federal Election Commission campaign finance data through MCP tools. Enables querying OpenFEC data using natural language via ask_pipeworx or direct tool calls.

reference-mcp

An MCP server that helps AI agents comprehend a codebase by providing tools for navigating, searching, and understanding code structure and history.

QMT MCP Server

Wraps the miniQMT interface to enable AI assistants to query A-share market data, account information, and place/cancel orders.

immich-photo-manager

Manage your self-hosted Immich photo library through conversation — natural language search via CLIP, geographic album curation, duplicate detection with perceptual hashing,

Trilium MCP Server

Brings your Trilium Notes knowledge base into Claude Desktop, enabling full-text search, note management, and content interaction through natural language.

Aegis

A compliance kernel for MCP that enforces policy rules between AI agents and data systems, providing deterministic access control, PII masking, and audit trails.

mcp-norwegian-weather

An MCP server that provides current weather conditions and hourly forecasts for locations across Norway using the MET Norway Locationforecast 2.0 API. It features coordinate support, geocoding for any Norwegian location, and built-in configurations for major cities.

Mochify MCP

MCP implementation for connecting to the Mochify image processing API to convert, compress and resize images.

Collective Brain MCP Server

Enables teams to create a shared knowledge base where members can store, search, and validate information collectively. Provides semantic search across team memories with granular permissions and collaborative verification features.

Replicate Recraft V3 MCP Server

Provides access to the recraft-ai/recraft-v3 image generation model via Replicate, supporting high-quality image creation with granular style, size, and aspect ratio controls. It features synchronous and asynchronous generation workflows, local image downloads in WebP format, and comprehensive prediction tracking.

linear-mcp

A Model Context Protocol server that enables interaction with Linear workspaces to manage issues, projects, cycles, and teams through a GraphQL interface. It provides 21 tools for comprehensive task management, search, and workflow coordination using OAuth2 authentication.

enigmagent-mcp

Local AES-256-GCM encrypted vault for AI agents. Resolve {{PLACEHOLDER}} secrets in prompts at runtime — LLMs never see real API keys. Argon2id key derivation, zero cloud.

ARCLinearGitHub-MCP

Bridges Linear issue tracking and GitHub repository management with ARC naming conventions, enabling composite workflows like creating a Linear issue and GitHub branch in one step.