Discover Awesome MCP Servers

Jina Free MCP

A Managed Component Provider that enables fetching webpage content using Jina AI's reader service.

ABAP-ADT-API MCP-Server

An MCP server that enables seamless communication between ABAP systems and MCP clients using the ABAP Development Tools (ADT) API. It provides tools for managing ABAP objects, handling transport requests, and performing code analysis directly through MCP-compatible interfaces.

Basic MCP Server

A minimal template server demonstrating MCP tools, resources, and prompts built with Smithery SDK. Provides starter examples including a hello tool, history resource, and greet prompt.

Test MCP

Server MCP sederhana untuk tujuan pengujian.

mcp-init

Okay, here's a basic outline and code snippets to get you started with creating a new Minecraft Protocol (MCP) server in TypeScript, with a focus on being "batteries included" (meaning including common features and dependencies). This will be a simplified example, and you'll need to expand upon it for a fully functional server. **Conceptual Outline** 1. **Project Setup:** Initialize a TypeScript project with necessary dependencies. 2. **Networking:** Set up a TCP server to listen for incoming Minecraft client connections. 3. **Protocol Handling:** Implement the Minecraft protocol (MCP) parsing and serialization. This is the most complex part. We'll use a library to help. 4. **Authentication:** Handle player authentication (online or offline mode). 5. **World Management:** Load or generate a world. 6. **Player Management:** Track connected players and their data. 7. **Game Logic:** Implement basic game logic (e.g., movement, chat). 8. **Command Handling:** Implement a command system for server administration. 9. **Logging:** Implement logging for debugging and monitoring. **Code Snippets (TypeScript)** **1. Project Setup** ```bash mkdir minecraft-server cd minecraft-server npm init -y npm install typescript ts-node ws minecraft-protocol @types/node --save npm install nodemon --save-dev # For automatic restarts during development ``` Create a `tsconfig.json` file: ```json { "compilerOptions": { "target": "es2020", "module": "commonjs", "outDir": "./dist", "rootDir": "./src", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true, "sourceMap": true }, "include": ["src/**/*"], "exclude": ["node_modules"] } ``` Add a `start` and `dev` script to your `package.json`: ```json "scripts": { "start": "node dist/index.js", "dev": "nodemon src/index.ts" }, ``` **2. `src/index.ts` (Main Server File)** ```typescript import * as net from 'net'; import { createServer } from 'minecraft-protocol'; import { Server, Client } from 'minecraft-protocol'; const serverOptions = { 'online-mode': false, // Disable online authentication for simplicity (offline mode) host: '0.0.0.0', // Listen on all interfaces port: 25565, // Default Minecraft port version: '1.19.4', // Minecraft version maxPlayers: 10, motd: 'My TypeScript Minecraft Server', favicon: 'data:image/png;base64,<YOUR_FAVICON_BASE64_HERE>' // Optional favicon }; const server: Server = createServer(serverOptions); server.on('login', (client: Client) => { console.log(`Player ${client.username} connected`); client.on('end', () => { console.log(`Player ${client.username} disconnected`); }); // Send initial game data (e.g., world information, player position) client.write('login', { entityId: 123, isHardcore: false, gameMode: 0, previousGameMode: -1, worldNames: ['minecraft:overworld'], dimensionCodec: { dimension: { type: 'compound', name: 'dimension', value: { ambient_light: { type: 'float', value: 0 }, bed_works: { type: 'byte', value: 1 }, coordinate_scale: { type: 'double', value: 1 }, effects: { type: 'string', value: 'minecraft:overworld' }, fixed_time: { type: 'long', value: 6000 }, has_ceiling: { type: 'byte', value: 0 }, has_raids: { type: 'byte', value: 1 }, has_skylight: { type: 'byte', value: 1 }, height: { type: 'int', value: 384 }, infiniburn: { type: 'string', value: 'minecraft:infiniburn_overworld' }, logical_height: { type: 'int', value: 256 }, min_y: { type: 'int', value: -64 }, monster_spawn_block_light_limit: { type: 'int', value: 0 }, monster_spawn_light_level: { type: 'int', value: 7 }, natural: { type: 'byte', value: 1 }, piglin_safe: { type: 'byte', value: 0 }, respawn_anchor_works: { type: 'byte', value: 0 }, require_skylight: { type: 'byte', value: 0 }, ultrawarm: { type: 'byte', value: 0 } } } }, dimension: 'minecraft:overworld', seed: [0, 0], maxPlayers: serverOptions.maxPlayers, isFlat: true, isDebug: false, hasLimitedFeature: false }); client.write('position', { x: 0, y: 64, z: 0, yaw: 0, pitch: 0, flags: 0, teleportId: 0 }); client.write('chat', { message: JSON.stringify({ translate: 'chat.type.announcement', with: [ 'Server', 'Welcome to the server!' ] }), position: 0, sender: '0' }); }); server.on('listening', () => { console.log(`Server listening on ${serverOptions.host}:${serverOptions.port}`); }); server.on('error', (err) => { console.error('Server error:', err); }); ``` **Explanation:** * **`minecraft-protocol`:** This library handles the complexities of the Minecraft protocol. It parses incoming packets and allows you to easily create and send packets. * **`createServer(serverOptions)`:** Creates the Minecraft server instance. * **`server.on('login', (client))`:** This event is triggered when a client successfully connects and authenticates (or skips authentication in offline mode). The `client` object represents the connected player. * **`client.on('end', ...)`:** Handles client disconnection. * **`client.write('login', ...)`:** Sends the initial login information to the client. This includes the entity ID, game mode, world information, and dimension information. The `dimensionCodec` is a complex structure that defines the properties of the world. * **`client.write('position', ...)`:** Sends the player's initial position in the world. * **`client.write('chat', ...)`:** Sends a chat message to the player. * **`server.on('listening', ...)`:** Logs a message when the server starts listening for connections. * **`server.on('error', ...)`:** Handles server errors. **3. Running the Server** 1. **Compile:** `npm run build` (or `tsc` if you have it globally installed). This will compile the TypeScript code into JavaScript in the `dist` directory. 2. **Run:** `npm start` (or `node dist/index.js`). If you're using `nodemon`, use `npm run dev`. **Important Considerations and Next Steps:** * **Error Handling:** The code above has minimal error handling. Add `try...catch` blocks and more robust error logging. * **World Generation:** You'll need to implement world generation. This is a complex topic. You can start with a simple flat world or explore more advanced world generation algorithms. Libraries like `prismarine-chunk` can help. * **Entity Management:** You'll need to manage entities (players, mobs, items) in the world. * **Packet Handling:** Implement handlers for other important packets, such as player movement, chat messages, block placement, etc. Use the `client.on('packet', ...)` event to listen for incoming packets. * **Security:** If you're running the server online, implement proper security measures to prevent cheating and attacks. Consider using online authentication. * **Plugins/Modding:** Design your server architecture to allow for plugins or mods to extend its functionality. * **Performance:** Optimize your code for performance, especially when handling large numbers of players or complex game logic. * **Data Storage:** Use a database (e.g., MongoDB, PostgreSQL) to store player data, world data, and other persistent information. **Example of Handling Player Chat:** ```typescript server.on('login', (client: Client) => { // ... (existing login code) ... client.on('chat', (data) => { const message = data.message; console.log(`${client.username}: ${message}`); // Broadcast the message to all other players for (const otherClient of server.clients) { if (otherClient !== client) { otherClient.write('chat', { message: JSON.stringify({ translate: 'chat.type.text', with: [ client.username, message ] }), position: 0, sender: '0' }); } } }); }); ``` This example shows how to listen for the `chat` packet and broadcast the message to all other connected players. This is a starting point. Building a full Minecraft server is a significant undertaking. Good luck!

GitHub GraphQL API MCP

Enables querying and exploring the GitHub GraphQL API schema and executing optimized GraphQL queries to retrieve precise GitHub data (repositories, issues, PRs, users) with reduced token consumption.

Zerodha Trading Bot MCP

An automated trading bot that interfaces with Zerodha to execute stock trades, manage positions, and access market information through natural language commands.

MCP Ctl

Manajer paket untuk mengelola semua server MCP Anda di berbagai platform.

Agoragentic

Agent-to-agent marketplace where AI agents discover, invoke, and pay for services from other agents using USDC on Base L2. 72+ services, free tools, x402 micropayments.

Cloudflare Playwright MCP

A Model Control Protocol server that enables AI assistants to control a browser through tools for web automation tasks like navigation, typing, clicking, and taking screenshots.

MCP MeloTTS Audio Generator

Enables AI assistants to convert text to high-quality speech audio using MeloTTS. Automatically splits long texts into segments, generates WAV files, and merges them using ffmpeg with support for multiple languages and customizable speech parameters.

mcp-server-hcp-terraform

MCP server untuk bekerja dengan HCP Terraform

Oracle DB Context

Provides contextual Oracle database schema information to AI assistants, enabling them to understand and work with large databases containing thousands of tables. Supports multi-database connections, smart schema caching, table lookups, and relationship mapping.

Get My Notion MCP Server

Provides access to a specific GitHub repository (my-notion) allowing AI assistants to browse files, read content, and track commit information. Enables real-time interaction with repository data through the GitHub API without authentication requirements.

Feifei Proxy MCP

A service that converts existing MCP protocols (stdio/sse) to streamable\_http transmission type, allowing compatibility between different MCP implementations.

Schwab MCP Server

A read-only MCP server that provides access to Charles Schwab account data and market information, including portfolio positions, real-time quotes, options chains, price history, and account balances through AI assistants.

Pearch

Best people search engine that reduces the time spent on talent discovery

Elisym Mcp Server

AI agents that hire other AI agents — and pay in SOL. Decentralized agent marketplace via Nostr + Solana.

selenium-mcp

A MCP server for Selenium can be translated to Indonesian as: * **Server MCP untuk Selenium** * **Server MCP bagi Selenium** (more formal) MCP likely refers to "Managed Cloud Platform" or something similar in this context. Without more context, it's difficult to provide a more precise translation.

mcp-server-bash

Server MCP minimalis yang ditulis dalam skrip bash.

Alpaca MCP Server

MCP server that exposes Alpaca Market Data & Broker API as tools, enabling access to financial data like stock bars, assets, market days, and news through the Message Control Protocol.

Aareguru MCP Server

Provides Swiss Aare river swimming data including water temperature, flow rates, safety assessments, and forecasts. Enables AI assistants to answer questions about current conditions, compare cities, and provide safety recommendations based on official BAFU thresholds.

ID Generator MCP

Provides AI assistants with capabilities to generate collision-resistant unique identifiers using UUID v4 and CUID2 algorithms.

MCP2Browser

Provides browser automation capabilities through HTTP, allowing AI assistants to navigate web pages and inspect content using Playwright-powered tools for opening URLs and retrieving page information.

Add API key to .env file

Tentu, berikut adalah implementasi sistem MCP (Master-Client-Process) sederhana dalam Python, termasuk klien dan beberapa server: **Konsep Dasar** * **Master:** Bertanggung jawab untuk mendistribusikan tugas ke server, memantau status server, dan mengumpulkan hasil. * **Server (Worker):** Menerima tugas dari master, memprosesnya, dan mengirimkan hasilnya kembali ke master. * **Klien:** Berinteraksi dengan master untuk mengirimkan tugas dan menerima hasil. **Kode (Python)** **1. Master (master.py)** ```python import socket import threading import queue HOST = '127.0.0.1' # Alamat IP untuk master PORT = 65432 # Port untuk master task_queue = queue.Queue() # Antrian tugas results = {} # Menyimpan hasil dari server server_count = 0 # Menghitung jumlah server yang terhubung server_addresses = [] # Menyimpan alamat server def handle_client(conn, addr): global server_count global server_addresses print(f"Server terhubung dari {addr}") server_count += 1 server_addresses.append(addr) try: while True: task = task_queue.get() # Ambil tugas dari antrian conn.sendall(str(task).encode()) # Kirim tugas ke server print(f"Tugas {task} dikirim ke {addr}") data = conn.recv(1024) # Terima hasil dari server if not data: break result = data.decode() print(f"Hasil dari {addr}: {result}") results[task] = result # Simpan hasil task_queue.task_done() # Tandai tugas selesai except ConnectionResetError: print(f"Koneksi dengan {addr} terputus.") finally: server_count -= 1 server_addresses.remove(addr) conn.close() print(f"Koneksi dengan {addr} ditutup.") def start_master(): global server_count with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.bind((HOST, PORT)) s.listen() print(f"Master mendengarkan di {HOST}:{PORT}") try: while True: conn, addr = s.accept() thread = threading.Thread(target=handle_client, args=(conn, addr)) thread.daemon = True # Agar thread berhenti saat program utama berhenti thread.start() except KeyboardInterrupt: print("\nMaster berhenti.") finally: print("Menunggu semua server selesai...") task_queue.join() # Tunggu semua tugas selesai print("Semua tugas selesai.") print("Hasil akhir:", results) print("Jumlah server yang terhubung:", server_count) print("Alamat server yang terhubung:", server_addresses) if __name__ == "__main__": # Contoh tugas (bisa diganti sesuai kebutuhan) tasks = [1, 2, 3, 4, 5] for task in tasks: task_queue.put(task) master_thread = threading.Thread(target=start_master) master_thread.start() master_thread.join() # Tunggu master selesai ``` **2. Server (server.py)** ```python import socket import time HOST = '127.0.0.1' # Alamat IP master PORT = 65432 # Port master def process_task(task): """Simulasi pemrosesan tugas.""" print(f"Server memproses tugas: {task}") time.sleep(2) # Simulasi waktu pemrosesan result = task * 2 # Contoh operasi return str(result) def start_server(): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: try: s.connect((HOST, PORT)) print(f"Terhubung ke master di {HOST}:{PORT}") while True: data = s.recv(1024) if not data: break task = int(data.decode()) result = process_task(task) s.sendall(result.encode()) except ConnectionRefusedError: print("Koneksi ke master ditolak. Pastikan master berjalan.") except Exception as e: print(f"Error: {e}") finally: s.close() print("Koneksi ke master ditutup.") if __name__ == "__main__": start_server() ``` **3. Klien (client.py) - *Opsional, untuk interaksi manual*** ```python import socket HOST = '127.0.0.1' # Alamat IP master PORT = 65432 # Port master def send_task(task): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: s.connect((HOST, PORT)) s.sendall(str(task).encode()) data = s.recv(1024) print(f"Hasil: {data.decode()}") if __name__ == "__main__": task = input("Masukkan tugas: ") send_task(task) ``` **Cara Menjalankan** 1. **Simpan:** Simpan kode di atas sebagai `master.py`, `server.py`, dan `client.py`. 2. **Jalankan Master:** Buka terminal/command prompt dan jalankan `python master.py`. 3. **Jalankan Server:** Buka beberapa terminal/command prompt *baru* dan jalankan `python server.py` di masing-masing terminal. Anda bisa menjalankan beberapa server secara paralel. 4. **Jalankan Klien (Opsional):** Jika Anda ingin mengirim tugas secara manual, jalankan `python client.py`. **Penjelasan** * **Socket:** Modul `socket` digunakan untuk komunikasi jaringan. * **Threading:** Modul `threading` digunakan agar master dapat menangani banyak server secara bersamaan. Setiap server yang terhubung akan ditangani dalam thread terpisah. * **Queue:** Modul `queue` digunakan untuk antrian tugas. Master memasukkan tugas ke dalam antrian, dan server mengambil tugas dari antrian. Ini membantu memastikan bahwa tugas didistribusikan secara adil ke semua server. * **Error Handling:** Kode menyertakan penanganan kesalahan dasar (misalnya, `ConnectionRefusedError`, `ConnectionResetError`) untuk membuat program lebih tangguh. * **Daemon Threads:** `thread.daemon = True` memastikan bahwa thread server akan berhenti ketika program master utama berhenti. Ini penting untuk menghindari thread yang menggantung. * **`task_queue.join()`:** Memastikan bahwa master menunggu semua tugas dalam antrian selesai diproses sebelum keluar. * **Contoh Tugas:** Dalam `master.py`, `tasks = [1, 2, 3, 4, 5]` adalah contoh tugas. Anda dapat menggantinya dengan tugas yang lebih kompleks, seperti nama file untuk diproses, atau data yang perlu dianalisis. * **`process_task()`:** Dalam `server.py`, fungsi `process_task()` adalah tempat Anda akan menempatkan logika pemrosesan tugas yang sebenarnya. Saat ini, hanya melakukan perkalian sederhana dan tidur sebentar untuk mensimulasikan pekerjaan. **Peningkatan Lebih Lanjut** * **Serialisasi Data:** Untuk tugas dan hasil yang lebih kompleks, gunakan serialisasi (misalnya, `pickle`, `JSON`) untuk mengubah objek Python menjadi format yang dapat dikirim melalui jaringan. * **Penanganan Kesalahan yang Lebih Baik:** Tambahkan penanganan kesalahan yang lebih komprehensif, termasuk pencatatan (logging) kesalahan. * **Konfigurasi:** Gunakan file konfigurasi untuk menyimpan pengaturan seperti alamat IP, port, dan jumlah server. * **Load Balancing:** Implementasikan algoritma load balancing yang lebih canggih untuk mendistribusikan tugas secara merata ke server berdasarkan kapasitas atau beban saat ini. * **Fault Tolerance:** Tambahkan mekanisme untuk mendeteksi dan menangani kegagalan server. * **Keamanan:** Gunakan enkripsi (misalnya, SSL/TLS) untuk mengamankan komunikasi antara master dan server. * **GUI:** Buat antarmuka grafis untuk memantau status sistem dan mengelola tugas. * **Distribusi Tugas Dinamis:** Master dapat secara dinamis menyesuaikan jumlah tugas yang diberikan ke setiap server berdasarkan kinerja server tersebut. * **Prioritas Tugas:** Implementasikan prioritas tugas sehingga tugas yang lebih penting dapat diproses terlebih dahulu. Contoh ini memberikan dasar yang kuat untuk membangun sistem MCP yang lebih kompleks dan kuat. Ingatlah untuk menyesuaikan kode dengan kebutuhan spesifik aplikasi Anda.

xtai-mcp-data-analysis

An MCP server for data analysis and visualization supporting CSV and Excel files. It enables users to generate statistical summaries and create multi-dimensional charts like heatmaps and bar plots through natural language.

sushimcp

sushimcp

mintlify-mcp

An MCP server that enables users to query any Mintlify-powered documentation site directly from Claude. It leverages Mintlify's AI Assistant API to provide RAG-based answers and code examples for various platforms like Agno, Resend, and Upstash.

MCP Google Workspace

Enables comprehensive management of Google Calendar, Contacts, and Gmail through AI systems. Supports full CRUD operations including creating/updating/deleting events, managing contacts, sending emails, organizing with labels, and batch operations with OAuth2 authentication.