Discover Awesome MCP Servers

MCP demo (DeepSeek as Client's LLM)

Run a MCP client & server demo with DeepSeek API

Apple Doc MCP

A Model Context Protocol server that provides AI coding assistants with direct access to Apple's Developer Documentation, enabling seamless lookup of frameworks, symbols, and detailed API references.

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.

mcp-shell

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

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.

BRAINS OS - version MCP

Implementasi MCP Serverless menggunakan SST, React, dan 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 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!

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.

MediaWiki Syntax MCP Server

This MCP server provides complete MediaWiki markup syntax documentation by dynamically fetching and consolidating information from official MediaWiki help pages. It enables LLMs to access up-to-date and comprehensive MediaWiki syntax information.

Overview

Mencoba server MCP untuk pertama kalinya.

Jokes MCP Server

A Model Context Protocol server that enables Microsoft Copilot Studio to fetch jokes from various sources including Chuck Norris jokes, Dad jokes, and Yo Mama jokes.

Outlook Calendar MCP Server

MCP server for accessing Outlook Calendar events via API

DiceDB MCP

Sebuah server MCP yang memungkinkan aplikasi AI berinteraksi dengan database DiceDB.

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.

OneTech MCP Server

Enables AI assistants to extract and document Mendix Studio Pro modules by interrogating local .mpr files. Generates comprehensive JSON documentation of domain models, pages, microflows, and enumerations without sending data to the cloud.

Reddit MCP Server

Provides access to Reddit's API for retrieving posts, comments, user information, and search functionality. Supports multiple authentication methods and comprehensive Reddit data operations including subreddit browsing, post retrieval, and user profile access.

Sentiment + Sarcasm Analyzer

A lightweight Gradio application that analyzes text for sentiment (positive/negative) and sarcasm detection using Hugging Face Transformers, designed to run on CPU and compatible with the MCP server architecture.

MCP Lambda Server

Paket Node.js yang menyediakan infrastruktur server Model Context Protocol untuk fungsi AWS Lambda dengan kemampuan respons streaming melalui Server-Sent Events.

Pokémon MCP Server

Enables interaction with live Pokémon data through PokeAPI, providing comprehensive Pokémon information, battle calculations, moveset validation, and team analysis. Supports searching Pokémon and moves, calculating stats, checking type effectiveness, and analyzing team synergies with in-memory caching for improved performance.

Market Data MCP Server

Enables fetching market and options data including OHLCV prices, option chains, Greeks, and corporate events through a pluggable FastAPI service. Supports creating aligned training datasets for financial analysis and uses yfinance by default with support for custom data providers.

Remote MCP Server Authless

A deployable MCP server on Cloudflare Workers that enables tool integration without authentication requirements, allowing connection from AI Playground or Claude Desktop.

JobNimbus MCP Remote Server

Enables remote access to JobNimbus CRM through Claude Desktop with 48+ tools for managing jobs, contacts, estimates, and advanced analytics. Features zero-storage security architecture where API keys are never stored on the server.

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.

mcp-victorialogs

mcp-victorialogs

Access Context Manager API MCP Server

An MCP server that provides access to Google's Access Context Manager API, enabling management of service perimeters and access levels through natural language.

Audius MCP Server

Mengaktifkan interaksi dengan API platform musik Audius, mendukung operasi pengguna, trek, dan daftar putar melalui Protokol Konteks Model.