Discover Awesome MCP Servers

MCP Mediator

Uma implementação em Java do mediador do Protocolo de Contexto de Modelo (MCP), fornecendo integração perfeita entre clientes e servidores MCP.

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.

Blender MCP for Antigravity

Windows-optimized MCP server that enables control of Blender 4.0+ through 21+ tools for scene management, object manipulation, and asset downloads from PolyHaven, Sketchfab, Hyper3D, and Hunyuan3D.

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.

MotaWord MCP Server

This MCP gives you full control over your translation projects from start to finish. You can log in anytime to see what stage your project is in — whether it’s being translated, reviewed, or completed. You don’t have to guess or follow up via email.

openai-gpt-image-mcp

An MCP server that enables image generation and editing using OpenAI's DALL-E models with support for text prompts, inpainting, and outpainting. It includes advanced features like automatic aspect ratio mapping and intelligent file management to handle large image payloads.

Riddles By Api Ninjas MCP Server

Enables access to the API Ninjas Riddles API to retrieve random riddles. Users can request between 1-20 riddles at a time through a simple interface.

Weather MCP Server

Enables LLMs to retrieve 24-hour weather forecasts and city information through natural language queries using city names or coordinates.

ALECS - MCP server for Akamai

MCP server for Akamai APIs. 198 tools covering Property Manager, Edge DNS, CPS, WAF, and reporting. Built with TypeScript, featuring modular architecture, comprehensive testing, and multi-account support. Make Akamai accessible to AI assistants.

Unity MCP Server

Provides AI assistants with comprehensive control over Unity Hub and Unity Editor through over 200 specialized tools for project management and scene manipulation. It enables users to perform complex tasks like script creation, asset management, and project builds using natural language commands.

Minecraft Bedrock Education MCP

Enables controlling Minecraft Bedrock and Education Edition through natural language commands via WebSocket connection. Provides tools for player actions, world manipulation, building structures, camera control, and wiki integration for automated gameplay and educational scenarios.

arXiv MCP Server

Enables searching and retrieving arXiv papers by topic, fetching abstracts by paper ID, and saving markdown content to files. Includes examples of integrating MCP tools with Google Gemini for AI-powered paper research.

FPL MCP Server

Connects LLMs to the Fantasy Premier League API for intelligent team management, enabling natural language player research, competitor analysis, transfer decisions, and strategic planning using friendly names instead of IDs.

JMeter MCP Server

Enables the execution and analysis of JMeter performance tests through MCP-compatible clients. It provides tools for running tests in non-GUI mode, identifying performance bottlenecks, and generating comprehensive insights and visualizations from result files.

BRAINS OS - version MCP

Uma implementação MCP (Multi-Cloud Provider) Serverless usando SST, React e AWS.

MCPizza

An MCP server that allows AI assistants to order Domino's Pizza through an unofficial API, with features for store location, menu browsing, and order management.

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.

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

heap-seance

MCP server that provides 8 tools for Java memory leak investigation: \- Class histograms, GC pressure snapshots, JFR recordings, heap dumps, MAT leak suspects analysis, async-profiler allocation profiles \- Structured confidence-based verdicts (none/low/medium/high) requiring independent signal corroboration \- Designed for use inside Claude Code with two slash commands

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.

ServiceDesk Plus MCP Server

A Model Context Protocol server for integrating with ServiceDesk Plus On-Premise that provides comprehensive CMDB functionality, allowing users to manage tickets, assets, software licenses, contracts, vendors, and administrative settings through natural language.

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.

claude-peers

Enables discovery and instant communication between multiple local Claude Code instances running across different projects. It allows agents to list active peers, share work summaries, and send messages through a local broker daemon.

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.

mcp-shell

Give hands to AI. MCP server to run shell commands securely, auditably, and on demand.