Discover Awesome MCP Servers

Scrapezy MCP Server

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

DiceDB MCP

Um servidor MCP que permite que aplicações de IA interajam com bancos de dados DiceDB.

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.

Base MCP Server

Enables AI applications to interact with the Base Network and Coinbase API for blockchain operations including wallet management, token transfers, smart contract deployment, NFT operations, and onchain lending through Morpho vaults.

Berry MCP Server

A universal framework for creating and deploying custom Model Context Protocol (MCP) tool servers with decorator-based tool registration, supporting multiple transports and automatic JSON schema generation for AI assistants.

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.

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.

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.

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.

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.

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 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.

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.

orchex

Autopilot AI orchestration — auto-plan, parallelize, self-heal, and route across 6 LLMs. Describe what you want. Orchex plans, parallelizes, and executes — safely.

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.

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.

e代驾 MCP Server

A service that provides complete driver-for-hire functionality based on e代驾 open APIs, enabling users to order drivers, calculate pricing, create and track orders.

MCP Fly Deployer

Servidor MCP que fornece arquivos Docker para um servidor MCP baseado em stdio para ser implantado em plataformas como Fly.IO.

Writer MCP

Enables creation and optimization of technical marketing content using Open Strategy Partners' methodologies, including writing guides, editing codes, SEO optimization, and product positioning frameworks.

Crypto Tracker MCP Server

Connects AI agents to real-time cryptocurrency market data from CoinGecko API, enabling price lookups, coin details, market rankings, search, and trending crypto queries through natural language.