Discover Awesome MCP Servers

InfraNodus MCP Server

Enables advanced text network analysis and knowledge graph generation using graph theory algorithms to identify topics, detect content gaps, and extract structured insights from unstructured text.

Qonto MCP Server

Enables interaction with the Qonto API v2 via 21 tools for organization, transactions, attachments, beneficiaries, clients, invoices, labels, memberships, requests, statements, and transfers, with GitHub OAuth authentication and stateful sessions.

@cryptoapis-io/mcp-signer

MCP server for local transaction signing across EVM, UTXO, Tron, and XRP blockchains, with no network calls or API keys required.

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.

GooodBilling

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

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.

Multi-Capability Proxy Server

A Flask-based server that hosts multiple tools, each exposing functionalities by calling external REST APIs through a unified interface.

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.

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.

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.

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.

PubMed MCP Server

Provides structured PubMed literature data for LLM agents, supporting search, caching, and open-access full-text downloads via the MCP protocol.

newrelic-mcp-server

Provides New Relic observability tools for AI assistants, enabling discovery, data access, alerting, incident response, and performance analytics via natural language queries.

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.

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.

README

Here's a basic example of an MCP (Minecraft Protocol) server implementation in Go. Keep in mind that a full MCP server is a complex project, and this is a simplified illustration to get you started. This example focuses on handling the initial handshake and sending a simple status response. ```go package main import ( "encoding/json" "fmt" "log" "net" ) // StatusResponse represents the server status information. 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"` } // writeVarInt writes a variable-length integer to the connection. func writeVarInt(conn net.Conn, value int) error { for { if (value & ^0x7F) == 0 { _, err := conn.Write([]byte{byte(value)}) return err } _, err := conn.Write([]byte{byte((value & 0x7F) | 0x80)}) if err != nil { return err } value >>= 7 } } // readVarInt reads a variable-length integer from the connection. func readVarInt(conn net.Conn) (int, error) { numRead := 0 result := 0 for { readBuf := make([]byte, 1) _, err := conn.Read(readBuf) if err != nil { return 0, err } value := int(readBuf[0] & 0x7f) result |= (value << (7 * numRead)) numRead++ if numRead > 5 { return 0, fmt.Errorf("VarInt is too big") } if (readBuf[0] & 0x80) == 0 { break } } return result, nil } // writeString writes a string to the connection, prefixed with its length as a VarInt. func writeString(conn net.Conn, str string) error { err := writeVarInt(conn, len(str)) if err != nil { return err } _, err = conn.Write([]byte(str)) return err } // readString reads a string from the connection, prefixed with its length as a VarInt. func readString(conn net.Conn) (string, error) { length, err := readVarInt(conn) if err != nil { return "", err } buf := make([]byte, length) _, err = conn.Read(buf) if err != nil { return "", err } return string(buf), nil } // handleConnection handles a single client connection. func handleConnection(conn net.Conn) { defer conn.Close() log.Printf("Client connected: %s", conn.RemoteAddr()) // 1. Read handshake packet packetLength, err := readVarInt(conn) if err != nil { log.Printf("Error reading packet length: %v", err) return } packetData := make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error reading packet data: %v", err) return } // Parse handshake data (very basic) // In a real server, you'd parse the protocol version, server address, and port. // For simplicity, we just read the packet ID. packetID := int(packetData[0]) if packetID != 0x00 { log.Printf("Unexpected packet ID: %x", packetID) return } // 2. Handle status request packetLength, err = readVarInt(conn) if err != nil { log.Printf("Error reading status request packet length: %v", err) return } packetData = make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error reading status request packet data: %v", err) return } packetID = int(packetData[0]) if packetID != 0x00 { log.Printf("Unexpected status request packet ID: %x", packetID) return } // 3. Send status response status := StatusResponse{ Version: struct { Name string `json:"name"` Protocol int `json:"protocol"` }{ Name: "Go MCP Server", Protocol: 757, // Example protocol version (Minecraft 1.17.1) }, Players: struct { Max int `json:"max"` Online int `json:"online"` Sample []struct { Name string `json:"name"` ID string `json:"id"` } `json:"sample"` }{ Max: 100, Online: 0, Sample: []struct { Name string `json:"name"` ID string `json:"id"` }{ {Name: "Player1", ID: "uuid1"}, {Name: "Player2", ID: "uuid2"}, }, }, Description: struct { Text string `json:"text"` }{ Text: "A Go-based Minecraft Server", }, } statusJSON, err := json.Marshal(status) if err != nil { log.Printf("Error marshaling status JSON: %v", err) return } // Construct the status response packet responsePacket := []byte{0x00} // Packet ID for status response responsePacketJSON := []byte(statusJSON) // Write the packet length responseLength := len(responsePacketJSON) + 1 // +1 for the packet ID err = writeVarInt(conn, responseLength) if err != nil { log.Printf("Error writing response packet length: %v", err) return } // Write the packet ID and JSON data _, err = conn.Write(append(responsePacket, responsePacketJSON...)) if err != nil { log.Printf("Error writing response packet data: %v", err) return } // 4. Handle ping request (optional) packetLength, err = readVarInt(conn) if err != nil { log.Printf("Error reading ping request packet length: %v", err) return } packetData = make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error reading ping request packet data: %v", err) return } packetID = int(packetData[0]) if packetID != 0x01 { log.Printf("Unexpected ping request packet ID: %x", packetID) return } // Echo back the ping payload _, err = conn.Write(append([]byte{0x01}, packetData[1:]...)) // Packet ID 0x01 for pong if err != nil { log.Printf("Error writing pong packet: %v", err) return } log.Println("Status response sent.") } func main() { listener, err := net.Listen("tcp", ":25565") if err != nil { log.Fatalf("Failed to listen: %v", err) } defer listener.Close() log.Println("Server listening on :25565") for { conn, err := listener.Accept() if err != nil { log.Printf("Failed to accept connection: %v", err) continue } go handleConnection(conn) } } ``` Key improvements and explanations: * **VarInt Handling:** The code now includes `writeVarInt` and `readVarInt` functions to correctly handle variable-length integers, which are crucial for the Minecraft protocol. These functions are essential for reading packet lengths and other data. The `readVarInt` function also includes error handling for excessively large VarInts, preventing potential denial-of-service attacks. * **String Handling:** Includes `writeString` and `readString` functions to handle strings, which are also prefixed with a VarInt length. * **Handshake Handling:** The `handleConnection` function now reads and *partially* parses the handshake packet. It checks the packet ID. A real implementation would need to parse the protocol version, server address, and port from the handshake data. * **Status Request Handling:** The code reads the status request packet (ID 0x00). * **Status Response:** The code constructs a `StatusResponse` struct, marshals it to JSON, and sends it back to the client. The `StatusResponse` struct is now more complete, including version, players, and description information. The protocol version is set to 757 (Minecraft 1.17.1). You'll need to update this for different Minecraft versions. * **Ping Handling (Optional):** The code now handles the ping request (ID 0x01) by echoing back the payload. This is important for the client to determine latency. * **Error Handling:** Includes more robust error handling throughout the code. Errors are logged with `log.Printf` to provide more context. * **Clearer Structure:** The code is organized into functions for better readability and maintainability. * **Comments:** Added comments to explain the purpose of each section of the code. * **JSON Marshaling:** Uses `encoding/json` to correctly marshal the status response into JSON format. * **Packet Construction:** The code now correctly constructs the status response packet, including the packet ID and the JSON data. It also calculates and writes the packet length using `writeVarInt`. * **Concurrency:** Uses `go handleConnection(conn)` to handle each client connection in a separate goroutine, allowing the server to handle multiple clients concurrently. * **Dependencies:** Only uses the standard Go library, making it easy to run. How to run: 1. **Save:** Save the code as `mcp_server.go`. 2. **Build:** Open a terminal and run `go build mcp_server.go`. 3. **Run:** Execute the compiled binary: `./mcp_server`. 4. **Connect:** Open Minecraft and try to add the server with the address `localhost:25565`. You might need to temporarily disable server authentication in your Minecraft client settings for testing purposes, or implement proper authentication in your server. Important considerations for a *real* MCP server: * **Protocol Versioning:** Minecraft's protocol changes with each version. You'll need to handle different protocol versions correctly. The handshake packet contains the protocol version. * **Data Types:** The Minecraft protocol uses specific data types (VarInt, VarLong, strings, etc.). You need to handle these correctly. * **Packet Handling:** A real server needs to handle a wide variety of packets, including login, chat, player movement, world updates, and more. * **World Generation:** You'll need to generate or load a Minecraft world. * **Entity Management:** You'll need to manage entities (players, mobs, etc.) in the world. * **Security:** Implement proper authentication and security measures to prevent unauthorized access and attacks. * **Performance:** Optimize your code for performance to handle a large number of players. * **Libraries:** Consider using existing Minecraft server libraries in Go to simplify development. However, be aware that the Go ecosystem for Minecraft server development is not as mature as the Java ecosystem. This example provides a foundation for building a more complete MCP server in Go. You'll need to study the Minecraft protocol documentation and implement the necessary features to create a fully functional server. Be prepared for a significant amount of work! ```go package main import ( "encoding/json" "fmt" "log" "net" ) // StatusResponse represents the server status information. 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"` } // writeVarInt writes a variable-length integer to the connection. func writeVarInt(conn net.Conn, value int) error { for { if (value & ^0x7F) == 0 { _, err := conn.Write([]byte{byte(value)}) return err } _, err := conn.Write([]byte{byte((value & 0x7F) | 0x80)}) if err != nil { return err } value >>= 7 } } // readVarInt reads a variable-length integer from the connection. func readVarInt(conn net.Conn) (int, error) { numRead := 0 result := 0 for { readBuf := make([]byte, 1) _, err := conn.Read(readBuf) if err != nil { return 0, err } value := int(readBuf[0] & 0x7f) result |= (value << (7 * numRead)) numRead++ if numRead > 5 { return 0, fmt.Errorf("VarInt is too big") } if (readBuf[0] & 0x80) == 0 { break } } return result, nil } // writeString writes a string to the connection, prefixed with its length as a VarInt. func writeString(conn net.Conn, str string) error { err := writeVarInt(conn, len(str)) if err != nil { return err } _, err = conn.Write([]byte(str)) return err } // readString reads a string from the connection, prefixed with its length as a VarInt. func readString(conn net.Conn) (string, error) { length, err := readVarInt(conn) if err != nil { return "", err } buf := make([]byte, length) _, err = conn.Read(buf) if err != nil { return "", err } return string(buf), nil } // handleConnection handles a single client connection. func handleConnection(conn net.Conn) { defer conn.Close() log.Printf("Client connected: %s", conn.RemoteAddr()) // 1. Read handshake packet packetLength, err := readVarInt(conn) if err != nil { log.Printf("Error reading packet length: %v", err) return } packetData := make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error reading packet data: %v", err) return } // Parse handshake data (very basic) // In a real server, you'd parse the protocol version, server address, and port. // For simplicity, we just read the packet ID. packetID := int(packetData[0]) if packetID != 0x00 { log.Printf("Unexpected packet ID: %x", packetID) return } // 2. Handle status request packetLength, err = readVarInt(conn) if err != nil { log.Printf("Error reading status request packet length: %v", err) return } packetData = make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error reading status request packet data: %v", err) return } packetID = int(packetData[0]) if packetID != 0x00 { log.Printf("Unexpected status request packet ID: %x", packetID) return } // 3. Send status response status := StatusResponse{ Version: struct { Name string `json:"name"` Protocol int `json:"protocol"` }{ Name: "Go MCP Server", Protocol: 757, // Example protocol version (Minecraft 1.17.1) }, Players: struct { Max int `json:"max"` Online int `json:"online"` Sample []struct { Name string `json:"name"` ID string `json:"id"` } `json:"sample"` }{ Max: 100, Online: 0, Sample: []struct { Name string `json:"name"` ID string `json:"id"` }{ {Name: "Player1", ID: "uuid1"}, {Name: "Player2", ID: "uuid2"}, }, }, Description: struct { Text string `json:"text"` }{ Text: "A Go-based Minecraft Server", }, } statusJSON, err := json.Marshal(status) if err != nil { log.Printf("Error marshaling status JSON: %v", err) return } // Construct the status response packet responsePacket := []byte{0x00} // Packet ID for status response responsePacketJSON := []byte(statusJSON) // Write the packet length responseLength := len(responsePacketJSON) + 1 // +1 for the packet ID err = writeVarInt(conn, responseLength) if err != nil { log.Printf("Error writing response packet length: %v", err) return } // Write the packet ID and JSON data _, err = conn.Write(append(responsePacket, responsePacketJSON...)) if err != nil { log.Printf("Error writing response packet data: %v", err) return } // 4. Handle ping request (optional) packetLength, err = readVarInt(conn) if err != nil { log.Printf("Error reading ping request packet length: %v", err) return } packetData = make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error reading ping request packet data: %v", err) return } packetID = int(packetData[0]) if packetID != 0x01 { log.Printf("Unexpected ping request packet ID: %x", packetID) return } // Echo back the ping payload _, err = conn.Write(append([]byte{0x01}, packetData[1:]...)) // Packet ID 0x01 for pong if err != nil { log.Printf("Error writing pong packet: %v", err) return } log.Println("Status response sent.") } func main() { listener, err := net.Listen("tcp", ":25565") if err != nil { log.Fatalf("Failed to listen: %v", err) } defer listener.Close() log.Println("Server listening on :25565") for { conn, err := listener.Accept() if err != nil { log.Printf("Failed to accept connection: %v", err) continue } go handleConnection(conn) } } ``` Here's the translation of the code and explanation to Indonesian: ```go package main import ( "encoding/json" "fmt" "log" "net" ) // StatusResponse merepresentasikan informasi status server. 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"` } // writeVarInt menulis integer dengan panjang variabel ke koneksi. func writeVarInt(conn net.Conn, value int) error { for { if (value & ^0x7F) == 0 { _, err := conn.Write([]byte{byte(value)}) return err } _, err := conn.Write([]byte{byte((value & 0x7F) | 0x80)}) if err != nil { return err } value >>= 7 } } // readVarInt membaca integer dengan panjang variabel dari koneksi. func readVarInt(conn net.Conn) (int, error) { numRead := 0 result := 0 for { readBuf := make([]byte, 1) _, err := conn.Read(readBuf) if err != nil { return 0, err } value := int(readBuf[0] & 0x7f) result |= (value << (7 * numRead)) numRead++ if numRead > 5 { return 0, fmt.Errorf("VarInt terlalu besar") } if (readBuf[0] & 0x80) == 0 { break } } return result, nil } // writeString menulis string ke koneksi, diawali dengan panjangnya sebagai VarInt. func writeString(conn net.Conn, str string) error { err := writeVarInt(conn, len(str)) if err != nil { return err } _, err = conn.Write([]byte(str)) return err } // readString membaca string dari koneksi, diawali dengan panjangnya sebagai VarInt. func readString(conn net.Conn) (string, error) { length, err := readVarInt(conn) if err != nil { return "", err } buf := make([]byte, length) _, err = conn.Read(buf) if err != nil { return "", err } return string(buf), nil } // handleConnection menangani satu koneksi klien. func handleConnection(conn net.Conn) { defer conn.Close() log.Printf("Klien terhubung: %s", conn.RemoteAddr()) // 1. Membaca paket handshake packetLength, err := readVarInt(conn) if err != nil { log.Printf("Error membaca panjang paket: %v", err) return } packetData := make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error membaca data paket: %v", err) return } // Mem-parse data handshake (sangat dasar) // Dalam server yang sebenarnya, Anda perlu mem-parse versi protokol, alamat server, dan port. // Untuk kesederhanaan, kita hanya membaca ID paket. packetID := int(packetData[0]) if packetID != 0x00 { log.Printf("ID paket tidak terduga: %x", packetID) return } // 2. Menangani permintaan status packetLength, err = readVarInt(conn) if err != nil { log.Printf("Error membaca panjang paket permintaan status: %v", err) return } packetData = make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error membaca data paket permintaan status: %v", err) return } packetID = int(packetData[0]) if packetID != 0x00 { log.Printf("ID paket permintaan status tidak terduga: %x", packetID) return } // 3. Mengirim respons status status := StatusResponse{ Version: struct { Name string `json:"name"` Protocol int `json:"protocol"` }{ Name: "Go MCP Server", Protocol: 757, // Contoh versi protokol (Minecraft 1.17.1) }, Players: struct { Max int `json:"max"` Online int `json:"online"` Sample []struct { Name string `json:"name"` ID string `json:"id"` } `json:"sample"` }{ Max: 100, Online: 0, Sample: []struct { Name string `json:"name"` ID string `json:"id"` }{ {Name: "Player1", ID: "uuid1"}, {Name: "Player2", ID: "uuid2"}, }, }, Description: struct { Text string `json:"text"` }{ Text: "Server Minecraft berbasis Go", }, } statusJSON, err := json.Marshal(status) if err != nil { log.Printf("Error me-marshal status JSON: %v", err) return } // Membuat paket respons status responsePacket := []byte{0x00} // ID paket untuk respons status responsePacketJSON := []byte(statusJSON) // Menulis panjang paket responseLength := len(responsePacketJSON) + 1 // +1 untuk ID paket err = writeVarInt(conn, responseLength) if err != nil { log.Printf("Error menulis panjang paket respons: %v", err) return } // Menulis ID paket dan data JSON _, err = conn.Write(append(responsePacket, responsePacketJSON...)) if err != nil { log.Printf("Error menulis data paket respons: %v", err) return } // 4. Menangani permintaan ping (opsional) packetLength, err = readVarInt(conn) if err != nil { log.Printf("Error membaca panjang paket permintaan ping: %v", err) return } packetData = make([]byte, packetLength) _, err = conn.Read(packetData) if err != nil { log.Printf("Error membaca data paket permintaan ping: %v", err) return } packetID = int(packetData[0]) if packetID != 0x01 { log.Printf("ID paket permintaan ping tidak terduga: %x", packetID) return } // Mengembalikan payload ping _, err = conn.Write(append([]byte{0x01}, packetData[1:]...)) // ID paket 0x01 untuk pong if err != nil { log.Printf("Error menulis paket pong: %v", err) return } log.Println("Respons status terkirim.") } func main() { listener, err := net.Listen("tcp", ":25565") if err != nil { log.Fatalf("Gagal mendengarkan: %v", err) } defer listener.Close() log.Println("Server mendengarkan di :25565") for { conn, err := listener.Accept() if err != nil { log.Printf("Gagal menerima koneksi: %v", err) continue } go handleConnection(conn) } } ``` **Penjelasan Tambahan (Indonesian):** * **MCP (Minecraft Protocol):** Ini adalah protokol komunikasi yang digunakan antara klien Minecraft dan server Minecraft. * **VarInt:** Integer dengan panjang variabel. Digunakan untuk menghemat bandwidth. Integer yang lebih kecil membutuhkan lebih sedikit byte untuk direpresentasikan. * **Handshake:** Paket pertama yang dikirim oleh klien ke server. Berisi informasi seperti versi protokol, alamat server, dan port. * **Status Request:** Permintaan dari klien untuk mendapatkan informasi tentang server (nama server, jumlah pemain online, dll.). * **Status Response:** Respons dari server yang berisi informasi status. * **Ping:** Permintaan dari klien untuk mengukur latensi (waktu tunda) ke server. * **Pong:** Respons dari server terhadap permintaan ping. * **Goroutine:** Fungsi yang berjalan secara konkuren (paralel) dengan fungsi lainnya. Digunakan untuk menangani banyak klien secara bersamaan. * **`encoding/json`:** Paket Go untuk bekerja dengan data JSON. * **`net`:** Paket Go untuk networking (koneksi jaringan). * **`log`:** Paket Go untuk logging (mencatat pesan). **Cara Menjalankan (Indonesian):** 1. **Simpan:** Simpan kode sebagai `mcp_server.go`. 2. **Kompilasi:** Buka terminal dan jalankan `go build mcp_server.go`. 3. **Jalankan:** Eksekusi file hasil kompilasi: `./mcp_server`. 4. **Hubungkan:** Buka Minecraft dan coba tambahkan server dengan alamat `localhost:25565`. Anda mungkin perlu menonaktifkan sementara otentikasi server di pengaturan klien Minecraft Anda untuk tujuan pengujian, atau mengimplementasikan otentikasi yang benar di server Anda. **Pertimbangan Penting untuk Server MCP *Asli* (Indonesian):** * **Versi Protokol:** Protokol Minecraft berubah dengan setiap versi. Anda perlu menangani versi protokol yang berbeda dengan benar. Paket handshake berisi versi protokol. * **Tipe Data:** Protokol Minecraft menggunakan tipe data tertentu (VarInt, VarLong, string, dll.). Anda perlu menangani ini dengan benar. * **Penanganan Paket:** Server yang sebenarnya perlu menangani berbagai macam paket, termasuk login, obrolan, pergerakan pemain, pembaruan dunia, dan banyak lagi. * **Pembuatan Dunia:** Anda perlu membuat atau memuat dunia Minecraft. * **Manajemen Entitas:** Anda perlu mengelola entitas (pemain, monster, dll.) di dunia. * **Keamanan:** Implementasikan otentikasi dan langkah-langkah keamanan yang tepat untuk mencegah akses tidak sah dan serangan. * **Performa:** Optimalkan kode Anda untuk performa agar dapat menangani sejumlah besar pemain. * **Pustaka (Libraries):** Pertimbangkan untuk menggunakan pustaka server Minecraft yang ada di Go untuk menyederhanakan pengembangan. Namun, perlu diingat bahwa ekosistem Go untuk pengembangan server Minecraft tidak sematang ekosistem Java. Contoh ini memberikan dasar untuk membangun server MCP yang lebih lengkap di Go. Anda perlu mempelajari dokumentasi protokol Minecraft dan mengimplementasikan fitur-fitur yang diperlukan untuk membuat server yang berfungsi penuh. Bersiaplah untuk pekerjaan yang signifikan!

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.

Markdown to PDF MCP Server

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

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.

sevdesk-mcp

Enables interaction with the sevDesk accounting API for managing contacts, invoices, credit notes, orders, vouchers, transactions, and parts.

BRAINS OS - version MCP

Implementasi MCP Serverless menggunakan SST, React, dan AWS.

openemr-wiki-mcp

A local-first MCP server that provides fast access to OpenEMR wiki pages, users guide, and selected API documentation through tools like search, page retrieval, and category listing.

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.

SEQ MCP Server

Enables LLMs to query and analyze logs from SEQ structured logging server with capabilities for searching events, retrieving event details, analyzing log patterns, and accessing saved searches.

Layout Detector MCP

Analyzes webpage screenshots to extract precise layout information by locating image assets and calculating spatial relationships, enabling AI assistants to accurately recreate layouts with proper semantic structure using computer vision.

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.