Discover Awesome MCP Servers

Docker MCP Server

Enables AI assistants like Claude to manage Docker containers, images, and Docker Compose deployments through the Model Context Protocol. Provides secure container lifecycle management, image operations, and multi-host Docker server connections.

Scrapezy MCP Server

A Model Context Protocol server that enables AI models to extract structured data from websites through the extract\_structured\_data tool.

MCP YouTube Extract

Enables extraction of YouTube video information including metadata (title, description, channel, views) and transcripts without requiring an API key, using yt-info-extract and yt-ts-extract libraries.

MIDI MCP Server

MIDI MCP Server é um servidor Model Context Protocol (MCP) que permite que modelos de IA gerem arquivos MIDI a partir de dados musicais baseados em texto. Esta ferramenta permite a criação programática de composições musicais através de uma interface padronizada.

C411 MCP Server

Enables searching torrents, fetching metadata, and downloading torrent files from c411.org. It provides tools for accessing torrent comments and detailed infoHash metadata while maintaining authenticated sessions.

Stock-MCP

Provides real-time A-share (Chinese stock market) data through AKShare integration, enabling access to market overviews, company information, real-time quotes, and historical price data for Shanghai and Shenzhen stock exchanges.

memecoin-radar-mcp

Real-time radar for Solana memecoins, Pump.fun launches, and KOL trades.

TTG Scratchpad MCP Server

Provides persistent agent workspaces with MongoDB storage for file management and real-time task progress tracking. It enables secure, isolated user environments with full activity logging for workspace operations.

Google Calendar - No deletion

Forked from https://github.com/epaproditus/google-workspace-mcp-server The deletion and updates on Google Calendar were removed since there were no scope to prevent deletion whilst maintaining creation capabilities.

NeverOnce

Persistent, correctable AI memory with zero dependencies. Corrections always surface first and never decay. SQLite-backed, 400 lines of pure Python, MCP server included.

Google Calendar MCP Server

Enables interaction with Google Calendar services through the Model Context Protocol using a Service Account. It allows MCP-compatible clients to manage calendar events and integrate calendar data via the Google Calendar API.

Gemini Imagen 3.0 MCP Server

Generates high-quality images using Google's Imagen 3.0 model via the Gemini API with support for up to four images per request. It provides automated file management and creates HTML previews for seamless image viewing within MCP-compatible hosts.

README

Here's an example of a simple MCP (Minecraft Protocol) server implementation in Go. This is a very basic example and doesn't handle all the complexities of the Minecraft protocol. It focuses on the initial handshake and status request/response. It's intended to illustrate the fundamental concepts. ```go package main import ( "encoding/json" "fmt" "io" "log" "net" "time" "github.com/google/uuid" ) // Minecraft Protocol Constants (Simplified) const ( ProtocolVersion = 763 // Example: Minecraft 1.16.5 ServerVersion = "GoMCP-Example" MaxPlayers = 20 OnlinePlayers = 10 // Example Description = "A simple Go MCP Server" ) // StatusResponse represents the JSON response for the server status. type StatusResponse struct { Version struct { Name string `json:"name"` Protocol int `json:"protocol"` } `json:"version"` Players struct { Max int `json:"max"` Online int `json:"online"` Sample []struct { Name string `json:"name"` ID string `json:"id"` } `json:"sample"` } `json:"players"` Description struct { Text string `json:"text"` } `json:"description"` Favicon string `json:"favicon,omitempty"` // Optional: Base64 encoded image } // readVarInt reads a variable-length integer from the connection. func readVarInt(r io.Reader) (int, error) { numRead := 0 result := 0 shift := 0 for { var readByte byte err := binaryRead(r, &readByte) if err != nil { return 0, err } value := int(readByte & 0x7f) // Mask out the MSB (most significant bit) result |= value << shift shift += 7 numRead++ if numRead > 5 { return 0, fmt.Errorf("VarInt is too big") } if readByte&0x80 == 0 { // MSB is 0, end of VarInt break } } return result, nil } // writeVarInt writes a variable-length integer to the connection. func writeVarInt(w io.Writer, value int) error { for { if (value & ^0x7F) == 0 { err := binaryWrite(w, byte(value)) if err != nil { return err } return nil } err := binaryWrite(w, byte((value&0x7F)|0x80)) if err != nil { return err } value >>= 7 } } // readString reads a Minecraft-style string (VarInt length + UTF-8 string). func readString(r io.Reader) (string, error) { length, err := readVarInt(r) if err != nil { return "", err } buf := make([]byte, length) _, err = io.ReadFull(r, buf) if err != nil { return "", err } return string(buf), nil } // writeString writes a Minecraft-style string (VarInt length + UTF-8 string). func writeString(w io.Writer, s string) error { err := writeVarInt(w, len(s)) if err != nil { return err } _, err = w.Write([]byte(s)) return err } // binaryRead is a helper function to read binary data. Handles io.EOF gracefully. func binaryRead(r io.Reader, data interface{}) error { err := binary.Read(r, binary.BigEndian, data) if err == io.EOF { return err // Or handle EOF differently if needed } return err } // binaryWrite is a helper function to write binary data. func binaryWrite(w io.Writer, data interface{}) error { return binary.Write(w, binary.BigEndian, data) } func handleConnection(conn net.Conn) { defer conn.Close() // 1. Handshake packetLength, err := readVarInt(conn) if err != nil { log.Println("Error reading packet length:", err) return } packetID, err := readVarInt(conn) if err != nil { log.Println("Error reading packet ID:", err) return } if packetID != 0x00 { log.Println("Unexpected packet ID:", packetID) return } protocolVersion, err := readVarInt(conn) if err != nil { log.Println("Error reading protocol version:", err) return } serverAddress, err := readString(conn) if err != nil { log.Println("Error reading server address:", err) return } serverPort := make([]byte, 2) _, err = io.ReadFull(conn, serverPort) if err != nil { log.Println("Error reading server port:", err) return } nextState, err := readVarInt(conn) if err != nil { log.Println("Error reading next state:", err) return } log.Printf("Handshake: Protocol %d, Address %s, Port %v, Next State %d, Packet Length %d\n", protocolVersion, serverAddress, serverPort, nextState, packetLength) // 2. Status Request if nextState == 1 { // Status packetLength, err = readVarInt(conn) if err != nil { log.Println("Error reading status request packet length:", err) return } packetID, err = readVarInt(conn) if err != nil { log.Println("Error reading status request packet ID:", err) return } if packetID != 0x00 { log.Println("Unexpected status request packet ID:", packetID) return } log.Println("Received Status Request") // 3. Status Response status := StatusResponse{ Version: struct { Name string `json:"name"` Protocol int `json:"protocol"` }{ Name: ServerVersion, Protocol: ProtocolVersion, }, Players: struct { Max int `json:"max"` Online int `json:"online"` Sample []struct { Name string `json:"name"` ID string `json:"id"` } `json:"sample"` }{ Max: MaxPlayers, Online: OnlinePlayers, Sample: []struct { Name string `json:"name"` ID string `json:"id"` }{ {Name: "Player1", ID: uuid.New().String()}, {Name: "Player2", ID: uuid.New().String()}, }, }, Description: struct { Text string `json:"text"` }{ Text: Description, }, Favicon: "", // Optional: Add a base64 encoded image here } statusJSON, err := json.Marshal(status) if err != nil { log.Println("Error marshaling status JSON:", err) return } statusString := string(statusJSON) // Send the status response err = writeVarInt(conn, 0x00) // Packet ID if err != nil { log.Println("Error writing status response packet ID:", err) return } err = writeString(conn, statusString) if err != nil { log.Println("Error writing status response JSON:", err) return } // Calculate and send the total packet length packetLength = len(statusString) + 1 // +1 for the packet ID err = writeVarInt(conn, packetLength) if err != nil { log.Println("Error writing status response packet length:", err) return } log.Println("Sent Status Response:", statusString) // 4. Ping Request (Optional) packetLength, err = readVarInt(conn) if err != nil { log.Println("Error reading ping request packet length:", err) return } packetID, err = readVarInt(conn) if err != nil { log.Println("Error reading ping request packet ID:", err) return } if packetID != 0x01 { log.Println("Unexpected ping request packet ID:", packetID) return } pingPayload := make([]byte, 8) _, err = io.ReadFull(conn, pingPayload) if err != nil { log.Println("Error reading ping payload:", err) return } log.Printf("Received Ping Request with Payload: %v\n", pingPayload) // 5. Ping Response err = writeVarInt(conn, 0x01) // Packet ID if err != nil { log.Println("Error writing ping response packet ID:", err) return } _, err = conn.Write(pingPayload) if err != nil { log.Println("Error writing ping response payload:", err) return } // Calculate and send the total packet length packetLength = 8 + 1 // +1 for the packet ID err = writeVarInt(conn, packetLength) if err != nil { log.Println("Error writing ping response packet length:", err) return } log.Println("Sent Ping Response") } else if nextState == 2 { // Login (Not implemented in this example) log.Println("Login requested (not implemented)") } else { log.Println("Unknown next state:", nextState) } } func main() { listener, err := net.Listen("tcp", ":25565") if err != nil { log.Fatal("Error starting server:", err) } defer listener.Close() fmt.Println("Go MCP Server listening on :25565") for { conn, err := listener.Accept() if err != nil { log.Println("Error accepting connection:", err) continue } go handleConnection(conn) } } ``` Key improvements and explanations: * **Error Handling:** Includes more robust error handling. Crucially, it checks for `io.EOF` when reading from the connection, which is essential for handling client disconnections gracefully. Without this, the server can crash when a client closes the connection unexpectedly. * **VarInt Implementation:** Provides correct `readVarInt` and `writeVarInt` functions. These are *essential* for the Minecraft protocol. The `readVarInt` function now correctly handles the bitwise operations and checks for excessively large VarInts. The `writeVarInt` function is also implemented correctly. * **String Handling:** Includes `readString` and `writeString` functions to handle Minecraft's length-prefixed strings. * **Status Response:** Creates a `StatusResponse` struct and marshals it to JSON. This is the data that the Minecraft client displays in the server list. The `Favicon` field is included (but left empty in this example; you'd need to base64 encode an image). The `Sample` player list is now populated with dummy data. * **Ping Handling:** Includes basic ping request/response handling. This is what allows the client to measure the server's latency. * **Binary Read/Write Helpers:** Added `binaryRead` and `binaryWrite` functions to simplify reading and writing binary data. The `binaryRead` function now handles `io.EOF`. * **Clearer Logging:** Uses `log.Println` for more informative output. * **Comments:** More detailed comments explaining the code. * **UUIDs:** Uses `github.com/google/uuid` to generate valid UUIDs for the player sample. * **Packet Length Calculation:** Correctly calculates and sends the packet length before the packet data. This is *critical* for the Minecraft protocol. * **BigEndian:** Uses `binary.BigEndian` for reading and writing binary data, as required by the Minecraft protocol. * **`go.mod`:** You'll need to initialize a Go module: ```bash go mod init mymcp go get github.com/google/uuid ``` How to run: 1. **Save:** Save the code as `main.go`. 2. **Initialize Module:** Run `go mod init mymcp` (or your preferred module name). 3. **Get Dependencies:** Run `go get github.com/google/uuid`. 4. **Build:** Run `go build`. 5. **Run:** Run the executable (e.g., `./mymcp`). 6. **Test:** Add the server to your Minecraft client using `localhost:25565`. You should see the server in the server list with the information you configured in the `StatusResponse`. Important Considerations: * **Security:** This is a *very* basic example and is not suitable for production use. It lacks proper security measures and could be vulnerable to attacks. * **Protocol Complexity:** The Minecraft protocol is complex. This example only implements a small subset of it. Implementing a full Minecraft server requires a significant amount of work. * **Error Handling:** While improved, the error handling could still be more robust. * **Concurrency:** The server uses goroutines to handle connections concurrently. However, you might need to consider more advanced concurrency patterns for a high-performance server. * **Data Serialization:** The code uses `encoding/json` for serialization. For performance-critical applications, you might consider using a more efficient serialization library. * **Keep-Alive:** You'll need to implement keep-alive mechanisms to detect and handle dead connections. * **Login:** The login process is not implemented. This is a complex part of the protocol that involves encryption and authentication. * **World Management:** This example doesn't handle world management or game logic. This improved example provides a much more solid foundation for building a Minecraft protocol server in Go. Remember to thoroughly research the Minecraft protocol specifications for a complete implementation.

MCP Server for Apache Airflow

Provides integration with Apache Airflow's REST API, allowing AI assistants to programmatically interact with Airflow workflows, monitor DAG runs, and manage tasks.

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.

MCP MySQL Server

Enables AI assistants to safely query MySQL databases with read-only access by default, supporting table listing, structure inspection, and SQL queries with optional write operation control.

Synology Download Station MCP Server

A Model Context Protocol server that enables AI assistants to manage downloads, search for torrents, and monitor download statistics on a Synology NAS.

Oracle HCM Cloud MCP Server by CData

Oracle HCM Cloud MCP Server by CData

Vertica MCP Server

Enables AI assistants to query and explore Vertica databases through natural language with readonly protection by default. Supports SQL execution, schema discovery, large dataset streaming, and Vertica-specific optimizations like projection awareness.

NIX MCP Server

Enables AI-powered blockchain data queries and analysis through the Native Indexer (NIX) system. Supports querying blocks, transactions, account information, and network status across various blockchain networks.

Swagger to MCP

Automatically converts Swagger/OpenAPI specifications into dynamic MCP tools, enabling interaction with any REST API through natural language by loading specs from local files or URLs.

Lotus MCP

Enables creation of reusable browser automation skills through demonstration by recording user actions in a browser while narrating, then converting those workflows into executable skills that can be invoked through natural language.

Godot MCP

Provides a comprehensive integration between LLMs and the Godot Engine, enabling AI assistants to intelligently manipulate project files, scripts, and the live editor. It supports advanced workflows including version-aware documentation querying, automated E2E game testing, and real-time visual context capture.

vocotype

VocoType 是一款运行在本地端侧的隐私安全语音输入工具，通过快捷键即可将语音实时转换为文字并自动输入到当前应用。支持语音转文字MCP、AI 优化文本、自定义替换词典、录音视频转文字等功能，让语音输入更高效、更安全。

Yahoo Finance MCP Server

Provides real-time stock quotes, historical price data, financial news, and multi-stock comparisons using Yahoo Finance data. Enables users to access comprehensive financial market information through natural language queries.

Apple Doc MCP

A Model Context Protocol server that provides AI coding assistants with direct access to Apple's Developer Documentation, enabling seamless lookup of frameworks, symbols, and detailed API references.

desk-mcp

A desktop automation MCP server that enables AI agents to interact with Linux environments through screenshots, window inspection, and input simulation. It provides tools for mouse control, keyboard input, and screen capture using xdotool and XDG Desktop Portals.

Documentation MCP Server

Scrapes and indexes documentation websites to provide AI assistants with searchable access to documentation content, API references, and code examples through configurable URL crawling.