Discover Awesome MCP Servers

bexio-mcp-server

Complete Swiss accounting integration for Bexio via MCP. Works with Claude Desktop, n8n, and any MCP client. 221 tools for invoices, contacts, projects & more. Created by Lukas Hertig.

plugged.in MCP Proxy Server

O Servidor MCP Plugged.in gerencia todos os seus outros MCPs em um único MCP.

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.

Prompt Cleaner MCP Server

Enables cleaning and sanitizing prompts through an LLM-powered tool that removes sensitive information, provides structured feedback with notes and risks, and normalizes prompt formatting. Supports configurable local or remote OpenAI-compatible APIs with automatic secret redaction.

Amazon Neptune MCP Server

Enables querying Amazon Neptune databases and analytics graphs using openCypher or Gremlin. It provides tools for executing queries, retrieving graph schemas, and monitoring connection status.

DiceDB MCP

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

MCP Civil Tools

A Python-based MCP server that provides coordinate conversion between latitude/longitude and UTM/TWD97, along with various civil engineering calculation tools for LLM and AI application integration.

FastlyMCP

Enables AI assistants to interact with Fastly's CDN API through the Model Context Protocol, allowing secure management of CDN services, caching, security settings, and performance monitoring without exposing API keys.

MCP E-commerce Server

Enables management of retail e-commerce products with CRUD operations, AI-powered product description generation, and inventory tracking through SQLite database integration.

DevEx MCP Server

AI-powered cloud development IDE, so you can run AI to surf in a secure sandbox environment.

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.

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.

Luma Events MCP Server

Enables users to search and discover upcoming tech events, conferences, and meetups from Luma (lu.ma) through natural language queries. Built on Cloudflare Workers for fast, global access to tech event data.

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 CLI

A command-line tool for creating and running Model Context Protocol servers that expose resources, tools, and prompts to LLM clients.

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.

Giphy MCP Server

This is an auto-generated Multi-Agent Conversation Protocol server that enables interaction with the Giphy API, allowing users to access and use Giphy's GIF services through natural language commands.

ImgMCP

Connecting Models to Your Creativity. We aspire to bring the unique capabilities of AI models to every creative individual, delivering better experiences, lower costs, and higher efficiency. This is the meaning behind our creation of ImgMCP.

Enhanced Knowledge Graph Memory Server

An enhanced fork of the official MCP memory server that enables persistent knowledge graph storage with automatic timestamps, tags, importance levels, date range search, comprehensive statistics, and multi-format export (JSON, CSV, GraphML).

qBittorrent MCP Server

Enables interaction with qBittorrent through its Web API to search for torrents using search plugins and manage downloads. Supports torrent searching, downloading via URLs/magnet links, and torrent management operations like pause, resume, and delete.

Vercel AI SDK MCP Server Project

Servidor MCP para Vercel AI SDK com integração Figma e magic-mcp.

PowerShell MCP Server

A server that enables programmatic execution of PowerShell scripts, clipboard operations, and terminal output capture via a JSON-RPC interface.

PDFtotext MCP Server

A reliable server for extracting text from PDF documents using the poppler-utils' pdftotext utility, compatible with any Model Context Protocol client.

Sourcegraph MCP Server

Provides AI-enhanced code search capabilities by integrating with Sourcegraph, allowing AI assistants to search across multiple repositories and codebases with advanced query syntax.

UCSC Genome Browser MCP Server

Provides comprehensive access to the UCSC Genome Browser API, enabling queries of genomic data, DNA sequences, gene annotations, variants, and metadata across multiple species and assemblies.

Clear Thought Server

Provide systematic thinking, mental models, and debugging approaches to enhance problem-solving capabilities. Enable structured reasoning and decision-making support for complex problems. Facilitate integration with MCP-compatible clients for advanced cognitive workflows.

Taskmaster MCP Server

Provides AI agents with simplified task management through a 4-step workflow (create session, define tasks, execute, complete) that works with any LLM without requiring complex thinking patterns.

microCMS MCP サーバ

Habilitar o uso da API microCMS no servidor MCP.