Discover Awesome MCP Servers

Storybook MCP Server

A Model Context Protocol server that integrates with Storybook to help AI tools query UI components and retrieve usage examples from static Storybook files.

Ansible MCP Server

This Model Context Protocol server enables AI assistants to interact directly with Ansible, allowing them to execute playbooks, manage inventory, check syntax, and perform other Ansible operations.

MCP Chat

A server that enables users to chat with each other by repurposing the Model Context Protocol (MCP), designed for AI tool calls, into a human-to-human communication system.

Brave Search With Proxy

Brave Search With Proxy

ClickUp MCP Server

Enables comprehensive project management through ClickUp's API, supporting task creation and updates, time tracking, goal management, and team collaboration within ClickUp's hierarchical workspace structure.

Fibaro HC3 MCP Server

Enables control of Fibaro Home Center 3 smart home devices through natural language commands. Supports device control, scene management, lighting adjustments, and RGB color changes with automatic HC3 connection.

Discord MCP Server

An MCP server for interacting with Discord.

GitHub

通过 GitHub API 实现与 GitHub 的交互，支持文件操作、仓库管理、高级搜索和问题跟踪，并提供全面的错误处理和自动分支创建功能。

Time MCP Server

一个模型上下文协议服务器，提供时间和时区转换功能，使大型语言模型（LLM）能够获取当前时间信息并使用 IANA 时区名称执行时区转换。

Deribit MCP Server

Enables real-time cryptocurrency price monitoring and intelligent alerts for Deribit exchange through Claude Desktop. Set price alerts using natural language and receive instant Telegram notifications when conditions are met.

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!

@tailor-platform/tailor-mcp

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

Ableton Copilot MCP

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

SVG to PNG MCP Server

一个模型上下文协议（Model Context Protocol）服务器，可以将 SVG 代码转换为 PNG 图像，提供两种转换方法（CairoSVG 和 Inkscape），并支持自定义工作目录。

Setup Agent MCP

Enables AI assistants to automatically analyze GitHub repositories and set up development environments by detecting tech stacks, installing dependencies, and verifying project builds. Provides safe tools for repository cloning, file system operations, package installation, and build verification through an allowlisted command system.

Sola MCP Server

A stateless HTTP server implementing the Model Context Protocol (MCP) that enables applications to interact with Social Layer platform data including events, groups, profiles, and venues via standardized endpoints.

🚀 Electron Debug MCP Server

🚀 一个强大的 MCP 服务器，用于调试 Electron 应用程序，并深度集成了 Chrome DevTools 协议。 通过标准化的 API 控制、监控和调试 Electron 应用程序。

FastAPI MCP OpenAPI

A FastAPI library that provides Model Context Protocol tools for endpoint introspection and OpenAPI documentation, allowing AI agents to discover and understand API endpoints.

Brave Search MCP Server

Enables web searching and local business discovery through the Brave Search API. Provides both general web search with pagination and filtering controls, plus local business search with automatic fallback to web results.

Tailscale MCP Server

Provides seamless integration with Tailscale's CLI commands and REST API, enabling automated network management and monitoring through a standardized Model Context Protocol interface.

Todo List MCP Server

A TypeScript-based MCP server that enables users to manage tasks through natural conversation with Claude. Features complete CRUD operations, priority management, tagging, search functionality, and intelligent productivity insights with robust Zod validation.

Google Workspace MCP Server

一个模型上下文协议服务器，提供与 Gmail 和 Calendar API 交互的工具，从而实现对电子邮件和日历事件的程序化管理。

auto-mcp

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

Clo MCP Plugin

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

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.