Discover Awesome MCP Servers

Railway MCP Server

Enables interaction with Railway cloud platform through the CLI to manage projects, services, deployments, and environments. Supports creating projects, deploying templates, managing environment variables, and monitoring logs through natural language commands.

Quickbase MCP Server

为通过 Claude 和其他 MCP 客户端与 Quickbase 的 JSON RESTful API 交互提供一个标准化的接口，支持诸如查询记录、管理表关系和处理文件附件等操作。

deepseek-mcp-server

MCP server for DeepSeek AI models (Chat + Reasoner). Supports multi-turn sessions, model fallback with circuit breaker, function calling, thinking mode, JSON output, multimodal input, and cost tracking.

Clo MCP Plugin

Clo MCP 插件是一个用 Clo3D SDK 构建的 C++ 应用程序。它在 Clo3D 中建立一个套接字服务器，允许大型语言模型 (LLM) 通过模型上下文协议 (MCP) 与 Clo3D 交互并控制它，从而实现高级 AI 辅助的服装设计和场景创建。

MCP VectorStore Server

Provides advanced document search and processing capabilities through vector stores, including PDF processing, semantic search, web search integration, and file operations. Enables users to create searchable document collections and retrieve relevant information using natural language queries.

agentek-eth

一个提供加密货币研究和基于以太坊的自动化工具的 MCP 服务器。

Crossword MCP Server

Enables solving crossword puzzles by loading grid and clue files, registering candidate words, checking consistency, and rendering final solutions. Supports Japanese crosswords with automated solving capabilities through natural language interaction.

VOICEPEAK MCP Server

Enables text-to-speech synthesis using VOICEPEAK software with support for custom narrators, emotions, and pronunciation dictionaries. Allows generating and playing audio files from text with configurable voice parameters.

MySQL查询服务器

镜子 (jìng zi)

MCP Google Server

提供使用 Google Custom Search API 的网页搜索功能，使用户能够通过模型上下文协议服务器执行搜索。

Italian Cities MCP Server

Provides CRUD tools for managing a database of Italian cities backed by Elasticsearch. It enables AI assistants to search, create, update, and delete city records through a standardized Model Context Protocol interface.

bach-bin_ip_checker

An MCP server that provides tools for credit card BIN lookups and IP address verification to help prevent fraudulent transactions. It enables users to validate card details and perform IP lookups using the Bin Ip Checker API.

auto-mcp

自动将函数、工具和代理转换为 MCP 服务器。

MCP Gateway

Aggregates multiple Model Context Protocol servers into a single gateway to provide unified search, description, and execution of tools. It reduces context limit issues by dynamically fetching specific tool schemas only when needed rather than loading all available tools at once.

Jokes MCP Server

Enables users to fetch random jokes from multiple sources including Chuck Norris jokes, Dad jokes, and Yo Mama jokes through integration with popular joke APIs.

MongoDB Mongoose MCP

Enables Claude to interact with MongoDB databases through natural language, supporting queries, aggregations, CRUD operations, and index management with optional Mongoose schema validation.

MineSkin MCP Server

Enables programmatic access to the MineSkin API for generating and managing Minecraft skins through natural language commands, auto-generated using AG2's MCP builder.

ElevenLabs Text-to-Speech MCP

通过模型上下文协议将 ElevenLabs 文本转语音功能集成到 Cursor 中，允许用户在 Cursor 编辑器内使用可选择的声音将文本转换为语音。

MCP Vector Proxy

A semantic proxy that reduces AI agent token usage by exposing only three core tools and using local vector embeddings to search for and execute hundreds of underlying MCP tools. It streamlines communication between agents and MCP Routers by identifying relevant tools through natural language queries.

Magento 2 MCP Server

A Model Context Protocol server that connects to a Magento 2 REST API, allowing Claude and other MCP clients to query product information, customer data, and order statistics from a Magento store.

Universal DB MCP

Enables Claude Desktop to interact with MySQL, PostgreSQL, and Redis databases using natural language for data querying and schema analysis. It provides a secure interface with a default read-only mode to prevent unauthorized database modifications.

MCP LLM Integration Server

Enables integration of local LLM capabilities with MCP-compatible clients like Claude Desktop, Continue.dev, and Cline. Provides tools for processing text prompts through local language models using a customizable inference function.

Kubernetes MCP Server

Enables comprehensive Kubernetes cluster management through kubectl operations and Helm chart management. Supports resource operations, logging, scaling, rollouts, and diagnostics with multiple transport modes and security features.

ipybox

A Python code execution sandbox based on IPython and Docker. Stateful code execution, file transfer between host and container, configurable network access.

DeepSeek MCP Server

Okay, here's a basic outline and code snippet for a simple MCP (presumably meaning something like "Message Control Protocol" or "Message Coordination Proxy" in this context) server in Go that redirects questions to Deepseek models. I'll focus on the core functionality: receiving a request, forwarding it to a Deepseek model (assuming a Deepseek API endpoint), and returning the response. **Important Considerations and Assumptions:** * **Deepseek API:** This code assumes you have access to a Deepseek API endpoint that accepts a question (likely as a JSON payload) and returns a response (also likely as JSON). You'll need to replace the placeholder URL (`"https://api.deepseek.com/v1/completions"`) with the actual Deepseek API endpoint. You'll also need to handle authentication (API keys, etc.) as required by the Deepseek API. * **Error Handling:** The code includes basic error handling, but you'll want to expand it for production use. Consider logging errors, implementing retry mechanisms, and providing more informative error responses to the client. * **JSON Handling:** The code uses JSON for request and response serialization. Adjust the data structures if the Deepseek API uses a different format. * **Concurrency:** The code handles each request in a separate goroutine, allowing the server to handle multiple requests concurrently. * **Dependencies:** You'll need the `net/http` and `encoding/json` packages, which are part of the Go standard library. You might also need a package like `io/ioutil` for reading the response body. * **Security:** This is a *very* basic example. For production, you'll need to consider security aspects like input validation, rate limiting, and authentication/authorization. * **MCP Definition:** I'm assuming "MCP" is a custom term in your context. This code provides a simple proxy/redirector. If MCP has more specific requirements (e.g., message queuing, transformation, routing rules), you'll need to adapt the code accordingly. **Code Example (main.go):** ```go package main import ( "bytes" "encoding/json" "fmt" "io" "log" "net/http" "os" ) // RequestPayload represents the structure of the incoming request. Adjust as needed. type RequestPayload struct { Question string `json:"question"` } // ResponsePayload represents the structure of the response from Deepseek. Adjust as needed. type ResponsePayload struct { Answer string `json:"answer"` } // deepseekAPIEndpoint is a placeholder. Replace with the actual Deepseek API URL. const deepseekAPIEndpoint = "https://api.deepseek.com/v1/completions" // Replace with the actual Deepseek API endpoint // deepseekAPIKey is a placeholder. Replace with your actual Deepseek API key. const deepseekAPIKey = "YOUR_DEEPSEEK_API_KEY" // Replace with your actual Deepseek API key func main() { http.HandleFunc("/", handleRequest) port := os.Getenv("PORT") if port == "" { port = "8080" // Default port } fmt.Printf("Server listening on port %s\n", port) log.Fatal(http.ListenAndServe(":"+port, nil)) } func handleRequest(w http.ResponseWriter, r *http.Request) { if r.Method != http.MethodPost { http.Error(w, "Method not allowed", http.StatusMethodNotAllowed) return } // Decode the incoming JSON request var requestPayload RequestPayload err := json.NewDecoder(r.Body).Decode(&requestPayload) if err != nil { http.Error(w, "Invalid request body: "+err.Error(), http.StatusBadRequest) return } // Forward the request to the Deepseek API deepseekResponse, err := forwardToDeepseek(requestPayload) if err != nil { http.Error(w, "Error forwarding to Deepseek: "+err.Error(), http.StatusInternalServerError) return } // Encode the Deepseek response as JSON and send it back to the client w.Header().Set("Content-Type", "application/json") err = json.NewEncoder(w).Encode(deepseekResponse) if err != nil { http.Error(w, "Error encoding response: "+err.Error(), http.StatusInternalServerError) return } } func forwardToDeepseek(requestPayload RequestPayload) (ResponsePayload, error) { // Prepare the request to Deepseek requestBody, err := json.Marshal(map[string]string{"prompt": requestPayload.Question}) // Adjust the payload as needed for Deepseek if err != nil { return ResponsePayload{}, fmt.Errorf("error marshaling request to Deepseek: %w", err) } req, err := http.NewRequest(http.MethodPost, deepseekAPIEndpoint, bytes.NewBuffer(requestBody)) if err != nil { return ResponsePayload{}, fmt.Errorf("error creating Deepseek request: %w", err) } req.Header.Set("Content-Type", "application/json") req.Header.Set("Authorization", "Bearer "+deepseekAPIKey) // Add API key if required // Send the request to Deepseek client := &http.Client{} resp, err := client.Do(req) if err != nil { return ResponsePayload{}, fmt.Errorf("error sending request to Deepseek: %w", err) } defer resp.Body.Close() // Read the response from Deepseek body, err := io.ReadAll(resp.Body) if err != nil { return ResponsePayload{}, fmt.Errorf("error reading Deepseek response: %w", err) } if resp.StatusCode != http.StatusOK { return ResponsePayload{}, fmt.Errorf("Deepseek API returned error: %s, status code: %d", string(body), resp.StatusCode) } // Decode the Deepseek response var deepseekResponse ResponsePayload err = json.Unmarshal(body, &deepseekResponse) if err != nil { return ResponsePayload{}, fmt.Errorf("error unmarshaling Deepseek response: %w", err) } return deepseekResponse, nil } ``` **How to Run:** 1. **Save:** Save the code as `main.go`. 2. **Dependencies:** Make sure you have Go installed. You don't need to install any external dependencies for this example, as it uses only the standard library. 3. **Replace Placeholders:** **Crucially, replace `"https://api.deepseek.com/v1/completions"` and `"YOUR_DEEPSEEK_API_KEY"` with the actual Deepseek API endpoint and your API key.** 4. **Run:** Open a terminal, navigate to the directory where you saved `main.go`, and run `go run main.go`. 5. **Test:** Use a tool like `curl` or Postman to send a POST request to `http://localhost:8080/` (or the port you configured). The request body should be JSON like this: ```json { "question": "What is the capital of France?" } ``` **Example `curl` command:** ```bash curl -X POST -H "Content-Type: application/json" -d '{"question": "What is the capital of France?"}' http://localhost:8080/ ``` **Explanation:** 1. **`main` Function:** * Sets up an HTTP handler that listens for requests on the root path (`/`). * Starts the HTTP server on port 8080 (or the port specified by the `PORT` environment variable). 2. **`handleRequest` Function:** * Checks if the request method is POST. * Decodes the JSON request body into a `RequestPayload` struct. * Calls `forwardToDeepseek` to send the question to the Deepseek API. * Encodes the Deepseek response as JSON and sends it back to the client. * Handles errors appropriately. 3. **`forwardToDeepseek` Function:** * Marshals the `RequestPayload` into a JSON payload suitable for the Deepseek API. **You'll need to adjust the structure of this payload to match the Deepseek API's requirements.** * Creates an HTTP request to the Deepseek API endpoint. * Sets the `Content-Type` header to `application/json`. * **Adds the Deepseek API key to the `Authorization` header (if required).** * Sends the request to the Deepseek API. * Reads the response from the Deepseek API. * Decodes the JSON response into a `ResponsePayload` struct. * Handles errors appropriately. **Chinese Translation of Key Concepts:** * **MCP Server:** MCP 服务器 (MCP fúwùqì) * **Redirect:** 重定向 (chóngdìngxiàng) * **Deepseek Model:** Deepseek 模型 (Deepseek móxíng) * **API Endpoint:** API 端点 (API duāndiǎn) * **JSON:** JSON (pronounced the same in Chinese) * **Request:** 请求 (qǐngqiú) * **Response:** 响应 (xiǎngyìng) * **Error Handling:** 错误处理 (cuòwù chǔlǐ) * **Concurrency:** 并发 (bìngfā) * **Authentication:** 身份验证 (shēnfèn yànzhèng) * **Authorization:** 授权 (shòuquán) * **Payload:** 负载 (fùzài) * **Goroutine:** Goroutine (pronounced the same in Chinese) **Further Improvements:** * **Configuration:** Use environment variables or a configuration file to store the Deepseek API endpoint, API key, and other settings. * **Logging:** Implement more robust logging using a library like `logrus` or `zap`. * **Metrics:** Add metrics to track the number of requests, response times, and error rates. * **Rate Limiting:** Implement rate limiting to prevent abuse of the Deepseek API. * **Caching:** Cache responses from the Deepseek API to improve performance and reduce costs. * **Health Checks:** Add a health check endpoint to monitor the server's status. * **Load Balancing:** If you need to handle a large volume of traffic, consider using a load balancer to distribute requests across multiple instances of the server. * **Input Validation:** Thoroughly validate the incoming `question` to prevent injection attacks or other security vulnerabilities. Remember to adapt the code to the specific requirements of the Deepseek API you are using. Good luck!

symbols-mcp

Read, inspect and navigate codebase symbols by connecting to a Language Server

@tailor-platform/tailor-mcp

Tailorctl 命令行实用程序，重点关注 MCP（模型上下文协议）服务器功能。

Ableton Copilot MCP

一个模型上下文协议服务器，能够与 Ableton Live 进行实时交互，从而使 AI 助手能够控制歌曲创作、音轨管理、片段操作和音频录制工作流程。