Discover Awesome MCP Servers

Sales-Engineering/RFP-Response MCP

Provides structured templates for security questionnaires, RFP responses, and competitive battlecards to help AI agents and sales engineers draft responses efficiently.

Universe MCP

Bridges legacy MultiValue databases to modern AI assistants like Claude Desktop, allowing natural language queries and data manipulation through a secure, OAuth-authenticated connection.

instantly-mcp

Enables MCP clients to read Instantly.ai analytics and manage leads, campaigns, Unibox, sender accounts, blocklist, and webhooks, with write actions gated behind confirm prompts and configurable safety policies.

Cortex Context MCP Adapter

Enables integration with Cortex Context services through the Model Context Protocol. Provides authenticated access to CortexGuardAI's context management capabilities for registered users.

mcp-ping-server-giulia-ai

A simple MCP server providing ping, echo, and TCP host health-check tools with latency measurement. It enables transport testing and real network connectivity checks through natural language.

Remote MCP Server (Authless)

A template for deploying MCP servers without authentication on Cloudflare Workers. Enables custom tool creation and integration with Claude Desktop and AI Playground through Server-Sent Events.

Spain AI Kit

A collection of MCP servers that connect AI assistants to Spanish open government data, including statistics, legislation, land registry, and weather forecasts.

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.

ark-asa-mcp

MCP server for Ark: Survival Ascended that enables RCON-based administration commands such as listing players, broadcasting messages, saving the world, and reading the game log.

orchex

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

Kanka MCP Server

Enables local interaction with the Kanka worldbuilding API via MCP, supporting CRUD operations on characters, locations, and other worldbuilding entities, as well as campaign listing and search.

Mentoring Inquiry Builder

Enables AI assistants to guide users through hiring an engineering-leadership mentor, from getting options and matching focus to designing a program and booking an intro call. It computes prices server-side and sends a formal itemized offer after explicit price agreement.

Qdrant RAG MCP Server

Provides RAG search and ask capabilities over markdown and text files using Qdrant vector database, with tools for ingestion, retrieval, and source management.

mcp-explorer

A controllable, observable MCP server for dynamically setting tools and intercepting calls in real time, useful as a mock/MITM harness for testing MCP clients.

HiveMind

An MCP orchestration server that coordinates multiple AI coding agents using Copilot CLI for parallel task execution with dependency management, file locking, and observability.

ai-delivery-coordination

MCP server for the ai-delivery-kit orchestration engine, exposing loop management and stall intervention tools for delivery coordination.

MCP Standards Server

A Model Context Protocol (MCP) server that provides intelligent, context-aware access to development standards, enabling LLMs to automatically select and apply appropriate standards based on project requirements.

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.

Markdown to PDF MCP Server

Enables AI assistants to convert Markdown files and content to beautifully formatted PDF documents using Playwright's Chromium engine.

terminal-guardian-mcp

Provides secure, sandboxed terminal access for AI assistants via the Model Context Protocol, with multi-layer risk analysis and auditable command execution.

bwiki-mcp

专为BWIKI编辑优化的MCP服务器，提供语义化工具用于页面编辑、分类管理、内容获取等操作。

NetPilot-MCP

Enables large language models to manage network devices (Cisco, Huawei, H3C, Ruijie) via Telnet/SSH, supporting command execution, configuration, and diagnostics.

@modootoday/datalab-extension-mcp

A local MCP server that lets an AI app read your Naver data through your own browser, using the session you are already logged into.

MemoSaver

Local-first MCP server that persists AI coding agent memory and session context, enabling seamless resume across sessions with searchable memories and checkpoints.

engine

Exposes self-owned AI agent plugins as tools to Claude Code via a stdio MCP server, allowing Claude to call system info, calculator, or scribe transcriber directly.

@striderlabs/mcp-uber

MCP server connector for Uber ride-sharing, enabling ride requests, fare estimates, and trip tracking via browser automation.

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.

GooodBilling

Lets AI agents create estimates/invoices, manage customers, and track payments on GooodBilling — a Japanese qualified-invoice (インボイス制度) compliant billing cloud.

Requirement Trace Checker

Enables users to analyze project materials and build traceability from requirements to coverage, identifying gaps.

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.