Discover Awesome MCP Servers

RyanNg

Cipher is an opensource memory layer specifically designed for coding agents. Compatible with Cursor, Windsurf, Claude Desktop, Claude Code, Gemini CLI, AWS's Kiro, VS Code, and Roo Code through MCP, and coding agents, such as Kimi K2.

docdex

Docdex is a lightweight, local documentation indexer/search daemon. It runs per-project, keeps an on-disk index of your markdown/text docs, and serves top-k snippets over HTTP or CLI for any coding assistant or tool—no external services or uploads required.

TFT MCP Server

Máy chủ này cho phép Claude truy cập dữ liệu trò chơi Đấu Trường Chân Lý (TFT), cho phép người dùng truy xuất lịch sử đấu và thông tin chi tiết về trận đấu thông qua API của Riot Games.

agentsvc-mcp

20 pay-per-call utility tools for AI agents via x402 USDC micropayments on Base. Screenshots, OCR, PDF, web scraping, weather, forex rates, crypto/stock prices, DNS, geocoding, translation, and more. $0.001–$0.008 per call. No API keys, no signup.

Pokémcp

Một máy chủ Giao thức Ngữ cảnh Mô hình (Model Context Protocol) cung cấp thông tin về Pokémon bằng cách kết nối với PokeAPI, cho phép người dùng truy vấn dữ liệu chi tiết về Pokémon, khám phá Pokémon ngẫu nhiên và tìm Pokémon theo khu vực hoặc loại.

Word of the Day MCP Server

Provides comprehensive word definitions, pronunciations, meanings, and examples for any English word using the Free Dictionary API. Includes a random word-of-the-day feature with difficulty levels for vocabulary building.

Tability MCP Server

Enables AI assistants to manage OKRs, track goals, and update progress on the Tability platform using natural language. It provides 27 tools for interacting with plans, objectives, outcomes, initiatives, and workspace memberships via the Tability API.

kubevirt-mcp-server

Một máy chủ giao thức ngữ cảnh mô hình đơn giản cho KubeVirt.

CarsXE

Decode VINs, look up specs, history, recalls, market value, and OBD codes. Recognize license plates and VINs from images. Access comprehensive vehicle data by year, make, and model to power automotive workflows.

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.

KTME - Knowledge Tracking & Management Engine

Tracks and manages code changes from Git repositories, generates documentation automatically, and provides AI agents with intelligent access to service documentation through MCP server integration with feature mapping and search capabilities.

ProtonMail Pro MCP

Enables comprehensive ProtonMail management through SMTP and IMAP, supporting email sending/reading, folder operations, analytics, and contact tracking with advanced search and automation capabilities.

VictoriaMetrics-mcp-server

VictoriaMetrics-mcp-server

Monad MCP Server

Enables interaction with the Monad testnet to check balances, examine transaction details, get gas prices, and retrieve block information.

backlog

Persistent, cross-session task management for Claude Code. 24 MCP tools for tasks, projects, dependencies, and docs. 7 skills for planning, standups, and handoffs. Event-sourced storage with per-project isolation.

Universal SQL MCP Server

Enables secure interaction with multiple SQL database engines (MySQL, PostgreSQL, SQLite, SQL Server) through a standardized interface. Supports schema inspection, safe query execution, and controlled write operations with built-in security restrictions.

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.

Dooray MCP Server

Enables integration with Dooray project management platform, allowing users to manage projects, tasks, comments, milestones, tags, and team members through natural language interactions.

outlook-mcp

MCP server for Microsoft Outlook via Graph API. 20 consolidated tools for email, calendar, contacts, folders, rules, categories, and settings with safety controls (dry-run preview, rate limiting, recipient allowlists) and MCP annotations on every tool.

Gemini Flash Image MCP Server

Enables text-to-image generation, image editing, and multi-image composition using Google's Gemini 2.5 Flash Image API. Supports flexible aspect ratios and character consistency across generations.

Apollo Proxy MCP Server

Provides AI agents with access to a global residential proxy network covering over 190 countries for web fetching and scraping. It enables pay-per-request transactions using USDC on the Base network via the x402 protocol.

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.

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.

Crypto Price & Market Analysis MCP Server

Provides comprehensive cryptocurrency analysis using the CoinCap API, offering real-time price data, market analysis across exchanges, and historical price trends for any cryptocurrency.

float-mcp

A community MCP server for float.com.

DeepSeek MCP Server

Okay, here's a basic outline and code snippet for a simple MCP (Minecraft Protocol) server in Go that redirects questions to Deepseek models. This is a simplified example and will require significant expansion to be a fully functional Minecraft server proxy. **Important Considerations:** * **Minecraft Protocol Complexity:** The Minecraft protocol is complex. This example only handles a tiny fraction of it. You'll need to study the protocol documentation (e.g., on the Minecraft Wiki) to handle more packet types. * **Deepseek API:** You'll need an account and API key for Deepseek. Replace `"YOUR_DEEPSEEK_API_KEY"` with your actual key. You'll also need to install the `go-openai` library. * **Error Handling:** This example has minimal error handling. Real-world code needs robust error handling. * **Security:** This is a basic example and doesn't include any security measures. Be very careful when exposing this to the internet. * **Performance:** Calling an external API for every chat message will introduce significant latency. Consider caching or other optimization techniques. * **Dependencies:** You'll need to install the `go-mc` and `go-openai` libraries. **Code (main.go):** ```go package main import ( "bufio" "context" "fmt" "log" "net" "strings" "github.com/go-mc/net/packet" "github.com/go-mc/net/proto" openai "github.com/sashabaranov/go-openai" ) const ( listenAddress = ":25565" // Address to listen on deepseekAPIKey = "YOUR_DEEPSEEK_API_KEY" // Replace with your Deepseek API key ) func main() { listener, err := net.Listen("tcp", listenAddress) if err != nil { log.Fatalf("Failed to listen: %v", err) } defer listener.Close() fmt.Printf("Listening on %s\n", listenAddress) for { conn, err := listener.Accept() if err != nil { log.Printf("Failed to accept connection: %v", err) continue } go handleConnection(conn) } } func handleConnection(conn net.Conn) { defer conn.Close() reader := bufio.NewReader(conn) // Handshake handshakePacket, err := readPacket(reader) if err != nil { log.Printf("Error reading handshake: %v", err) return } // Parse Handshake packet var protocolVersion int32 var serverAddress string var serverPort uint16 var nextState int32 err = handshakePacket.Scan(&protocolVersion, &serverAddress, &serverPort, &nextState) if err != nil { log.Printf("Error scanning handshake: %v", err) return } fmt.Printf("Protocol Version: %d, Server Address: %s, Server Port: %d, Next State: %d\n", protocolVersion, serverAddress, serverPort, nextState) if nextState == 1 { // Status // Handle Status request (Ping) - Basic example _, err = readPacket(reader) // Read request if err != nil { log.Printf("Error reading status request: %v", err) return } statusResponse := `{"version":{"name":"Deepseek Proxy","protocol":763},"players":{"max":100,"online":0,"sample":[]},"description":{"text":"A proxy powered by Deepseek"}}` writeStatusResponse(conn, statusResponse) _, err = readPacket(reader) // Read ping if err != nil { log.Printf("Error reading ping: %v", err) return } writePongResponse(conn, 12345) // Example ping id } else if nextState == 2 { // Login loginStartPacket, err := readPacket(reader) if err != nil { log.Printf("Error reading login start: %v", err) return } var username string err = loginStartPacket.Scan(&username) if err != nil { log.Printf("Error scanning login start: %v", err) return } fmt.Printf("Login attempt by: %s\n", username) // Send Login Success writeLoginSuccess(conn, "00000000-0000-0000-0000-000000000000", username) // Handle Play state (Chat messages) handlePlayState(conn, reader) } else { fmt.Println("Unknown next state:", nextState) } } func handlePlayState(conn net.Conn, reader *bufio.Reader) { for { packet, err := readPacket(reader) if err != nil { log.Printf("Error reading packet in play state: %v", err) return } packetID := packet.ID if packetID == 0x03 { // Chat Message (Clientbound) - Adjust ID if needed for your version var message string err = packet.Scan(&message) if err != nil { log.Printf("Error scanning chat message: %v", err) continue } fmt.Printf("Received chat message: %s\n", message) // Extract the actual question from the message (you might need more sophisticated parsing) question := message // Assuming the entire message is the question // Get Deepseek's response response, err := getDeepseekResponse(question) if err != nil { log.Printf("Error getting Deepseek response: %v", err) response = "Error: Could not get response from Deepseek." } // Send the response back to the client as a chat message. sendChatMessage(conn, response) } else { // Handle other packets or ignore them. This is crucial for a real proxy. fmt.Printf("Received packet ID: 0x%X (Ignoring)\n", packetID) } } } func getDeepseekResponse(question string) (string, error) { client := openai.NewClient(deepseekAPIKey) resp, err := client.CreateChatCompletion( context.Background(), openai.ChatCompletionRequest{ Model: openai.GPT3Dot5Turbo, // Or another suitable Deepseek model Messages: []openai.ChatCompletionMessage{ { Role: openai.ChatMessageRoleUser, Content: question, }, }, }, ) if err != nil { return "", err } return resp.Choices[0].Message.Content, nil } func sendChatMessage(conn net.Conn, message string) { // Construct a Chat Message packet (Serverbound) var buf packet.Buffer buf.WriteVarInt(0x0F) // Packet ID for Chat Message (Serverbound) - Adjust for your version buf.WriteString(message) buf.WriteByte(0) // Position (0: chat box, 1: system message, 2: game_info) writePacket(conn, buf) } func readPacket(reader *bufio.Reader) (packet.Packet, error) { var p packet.Packet var length int32 // Read the packet length (VarInt) num, err := proto.ReadVarInt(reader) if err != nil { return p, err } length = int32(num) // Read the packet data data := make([]byte, length) n, err := reader.Read(data) if err != nil { return p, err } if int32(n) != length { return p, fmt.Errorf("read %d bytes, expected %d", n, length) } p.ID, err = proto.ReadVarInt(bufio.NewReader(strings.NewReader(string(data)))) if err != nil { return p, err } p.Data = data[proto.VarIntLen(int32(p.ID)):] return p, nil } func writePacket(conn net.Conn, buf packet.Buffer) error { packetData := buf.Bytes() packetLength := len(packetData) var lengthBuf packet.Buffer lengthBuf.WriteVarInt(int32(packetLength)) _, err := conn.Write(lengthBuf.Bytes()) if err != nil { return err } _, err = conn.Write(packetData) return err } func writeStatusResponse(conn net.Conn, json string) error { var buf packet.Buffer buf.WriteVarInt(0x00) // Packet ID for Status Response buf.WriteString(json) return writePacket(conn, buf) } func writePongResponse(conn net.Conn, pingID int64) error { var buf packet.Buffer buf.WriteVarInt(0x01) // Packet ID for Pong buf.WriteLong(pingID) return writePacket(conn, buf) } func writeLoginSuccess(conn net.Conn, uuid, username string) error { var buf packet.Buffer buf.WriteVarInt(0x02) // Packet ID for Login Success buf.WriteString(uuid) buf.WriteString(username) return writePacket(conn, buf) } ``` **Explanation:** 1. **Imports:** Imports necessary packages for networking, reading/writing data, and interacting with the Deepseek API. 2. **Constants:** Defines the listening address and your Deepseek API key. **Replace `"YOUR_DEEPSEEK_API_KEY"`!** 3. **`main` Function:** * Listens for incoming TCP connections on the specified address. * Accepts connections and spawns a goroutine to handle each connection. 4. **`handleConnection` Function:** * Reads the initial handshake packet from the client. * Parses the handshake to determine the client's intended state (Status or Login). * Handles the Status state (Ping) by sending a status response and pong. * Handles the Login state by sending a login success packet and then calling `handlePlayState`. 5. **`handlePlayState` Function:** * This is the core logic for handling the game. * It reads packets from the client in a loop. * If it receives a chat message packet (ID `0x03` - **This ID is version-specific! Check your Minecraft version's protocol**), it extracts the message. * Calls `getDeepseekResponse` to get a response from Deepseek. * Sends the Deepseek response back to the client as a chat message using `sendChatMessage`. * **Crucially:** It includes a placeholder for handling other packet types. A real proxy needs to handle many more packet types to function correctly. 6. **`getDeepseekResponse` Function:** * Uses the `go-openai` library to send the question to Deepseek and retrieve the response. * Handles potential errors from the Deepseek API. 7. **`sendChatMessage` Function:** * Constructs a chat message packet to send back to the client. **The packet ID (`0x0F`) is version-specific!** 8. **`readPacket` Function:** * Reads a Minecraft packet from the input stream. Minecraft packets are length-prefixed with a VarInt. 9. **`writePacket` Function:** * Writes a Minecraft packet to the output stream, including the length prefix. 10. **`writeStatusResponse`, `writePongResponse`, `writeLoginSuccess` Functions:** * Helper functions to construct and send specific packets. **To Run:** 1. **Install Go:** Make sure you have Go installed. 2. **Install Dependencies:** ```bash go get github.com/go-mc/net/packet go get github.com/go-mc/net/proto go get github.com/sashabaranov/go-openai ``` 3. **Replace API Key:** Replace `"YOUR_DEEPSEEK_API_KEY"` with your actual Deepseek API key. 4. **Run the Code:** `go run main.go` 5. **Configure Minecraft:** In your Minecraft client, add a server with the address `localhost:25565` (or the address you configured). 6. **Chat:** Join the server and type a message in the chat. The message will be sent to Deepseek, and the response will be displayed in the Minecraft chat. **Vietnamese Translation of Key Points:** * **Giao thức Minecraft phức tạp:** Giao thức Minecraft rất phức tạp. Ví dụ này chỉ xử lý một phần nhỏ của nó. Bạn cần nghiên cứu tài liệu giao thức để xử lý nhiều loại gói tin hơn. * **API Deepseek:** Bạn cần có tài khoản và khóa API cho Deepseek. Thay thế `"YOUR_DEEPSEEK_API_KEY"` bằng khóa API thực tế của bạn. Bạn cũng cần cài đặt thư viện `go-openai`. * **Xử lý lỗi:** Ví dụ này có xử lý lỗi tối thiểu. Mã thực tế cần xử lý lỗi mạnh mẽ. * **Bảo mật:** Đây là một ví dụ cơ bản và không bao gồm bất kỳ biện pháp bảo mật nào. Hãy cẩn thận khi đưa nó lên internet. * **Hiệu suất:** Gọi API bên ngoài cho mỗi tin nhắn trò chuyện sẽ gây ra độ trễ đáng kể. Hãy xem xét việc lưu vào bộ nhớ cache hoặc các kỹ thuật tối ưu hóa khác. * **Phụ thuộc:** Bạn cần cài đặt các thư viện `go-mc` và `go-openai`. * **ID gói tin (Packet ID):** ID của các gói tin như tin nhắn chat (0x03, 0x0F) và các gói tin khác *thay đổi theo phiên bản Minecraft*. Bạn *cần* kiểm tra ID chính xác cho phiên bản Minecraft mà bạn đang sử dụng. **Next Steps:** * **Implement More Packet Handling:** Handle essential packets like player movement, entity updates, world data, etc. * **Implement Proxying:** Instead of just responding to chat messages, forward other packets to a real Minecraft server and back. * **Error Handling:** Add comprehensive error handling. * **Configuration:** Allow configuration of the Deepseek model, API key, and other settings. * **Rate Limiting:** Implement rate limiting to prevent abuse of the Deepseek API. * **Caching:** Cache Deepseek responses to improve performance. * **Security:** Add security measures to protect the proxy. This is a starting point. Building a full Minecraft proxy is a significant undertaking. Good luck!

🚀 Electron Debug MCP Server

🚀 Một máy chủ MCP mạnh mẽ để gỡ lỗi các ứng dụng Electron với tích hợp sâu Giao thức Chrome DevTools. Kiểm soát, giám sát và gỡ lỗi các ứng dụng Electron thông qua một API tiêu chuẩn.

Ableton Copilot MCP

Một máy chủ Giao thức Bối cảnh Mô hình (Model Context Protocol) cho phép tương tác thời gian thực với Ableton Live, cho phép các trợ lý AI kiểm soát việc tạo bài hát, quản lý track, các thao tác clip và quy trình làm việc ghi âm.

Vercel MCP Server

A Model Control Protocol server template deployed on Vercel that demonstrates MCP implementation with a dice rolling tool, serving as a foundation for building custom MCP servers.