Discover Awesome MCP Servers

Enrichment MCP Server

A Model Context Protocol server that enables users to perform third-party enrichment lookups for security observables (IP addresses, domains, URLs, emails) through services like VirusTotal, Shodan, and others.

SQLx MCP Server

Provides comprehensive database management tools for PostgreSQL, MySQL, and SQLite databases. Enables querying table structures, executing read-only and write queries, exporting DDL statements, and managing database metadata through natural language.

MCP server for LogSeq

Interacts with LogSeq via its API.

Claude Kali MCP Commander

An MCP server that provides secure access to Kali Linux cybersecurity tools through Claude's interface, enabling users to run Kali Linux commands directly from Claude Desktop.

CockroachDB MCP Server

The CockroachDB MCP Server is a natural language interface designed for agentic applications and LLMs to manage, monitor and query data in CockroachDB.

Echo MCP Server

Server sederhana yang mengimplementasikan Model Context Protocol (MCP) yang menggemakan pesan kembali, dirancang untuk menguji klien MCP.

Fetch MCP Server

Okay, here's a breakdown of how you can fetch URLs from a webpage using Playwright, integrate it with an SSE (Server-Sent Events) MCP (Management Control Protocol) server, and use Node.js with Express.js to orchestrate everything. I'll provide code snippets and explanations to guide you. **Conceptual Overview** 1. **Playwright (Web Scraping):** Playwright will be used to launch a browser, navigate to the target webpage, and extract the URLs you need. 2. **Node.js/Express.js (Server):** Express.js will create a web server that handles requests from clients (e.g., a web browser or another application). This server will: * Receive requests to start the URL fetching process. * Orchestrate the Playwright scraping. * Send progress updates and results back to the client using Server-Sent Events (SSE). 3. **SSE (Server-Sent Events):** SSE is a one-way communication protocol where the server pushes updates to the client in real-time. This is ideal for providing progress updates as the scraping happens. 4. **MCP (Management Control Protocol):** The term "MCP" is a bit vague in this context. I'm assuming it refers to a system or protocol for managing and controlling the scraping process. In this example, I'll treat it as a way to send commands to the server (e.g., "start scraping," "stop scraping," "set target URL"). You might need to adapt this part based on the specifics of your MCP implementation. **Code Example (Illustrative)** **1. Project Setup** ```bash mkdir playwright-sse-scraper cd playwright-sse-scraper npm init -y npm install express playwright eventsource ``` **2. `server.js` (Node.js/Express.js Server)** ```javascript const express = require('express'); const { chromium } = require('playwright'); const EventEmitter = require('events'); const app = express(); const port = 3000; app.use(express.json()); // For parsing JSON request bodies // Event emitter for SSE updates const sseEmitter = new EventEmitter(); let browser = null; // Playwright browser instance let page = null; // Playwright page instance let isScraping = false; let targetUrl = ''; let scrapedUrls = []; // Function to start Playwright and navigate to the target URL async function initializePlaywright(url) { try { browser = await chromium.launch({ headless: true }); // Or false for debugging page = await browser.newPage(); await page.goto(url); return true; } catch (error) { console.error("Error initializing Playwright:", error); sseEmitter.emit('update', { type: 'error', message: `Playwright initialization failed: ${error.message}` }); return false; } } // Function to extract URLs from the page async function extractUrls() { try { const urls = await page.evaluate(() => { const links = Array.from(document.querySelectorAll('a')); return links.map(link => link.href); }); return urls; } catch (error) { console.error("Error extracting URLs:", error); sseEmitter.emit('update', { type: 'error', message: `URL extraction failed: ${error.message}` }); return []; } } // Function to scrape URLs async function scrape(url) { if (!isScraping) { sseEmitter.emit('update', { type: 'status', message: 'Scraping stopped.' }); return; } if (!browser || !page) { const initialized = await initializePlaywright(url); if (!initialized) { isScraping = false; return; } } sseEmitter.emit('update', { type: 'status', message: 'Scraping in progress...' }); try { const newUrls = await extractUrls(); scrapedUrls = [...new Set([...scrapedUrls, ...newUrls])]; // Deduplicate sseEmitter.emit('update', { type: 'urls', urls: newUrls }); sseEmitter.emit('update', { type: 'status', message: `Found ${newUrls.length} new URLs. Total: ${scrapedUrls.length}` }); // Example: Scroll down to load more content (adjust as needed) await page.evaluate(() => { window.scrollBy(0, window.innerHeight); }); await page.waitForTimeout(2000); // Wait for content to load if (isScraping) { scrape(url); // Recursive call to continue scraping } else { sseEmitter.emit('update', { type: 'status', message: 'Scraping completed.' }); await browser.close(); browser = null; page = null; } } catch (error) { console.error("Scraping error:", error); sseEmitter.emit('update', { type: 'error', message: `Scraping failed: ${error.message}` }); isScraping = false; if (browser) { await browser.close(); browser = null; page = null; } } } // SSE endpoint app.get('/events', (req, res) => { res.setHeader('Content-Type', 'text/event-stream'); res.setHeader('Cache-Control', 'no-cache'); res.setHeader('Connection', 'keep-alive'); res.flushHeaders(); const listener = (data) => { res.write(`data: ${JSON.stringify(data)}\n\n`); }; sseEmitter.on('update', listener); req.on('close', () => { sseEmitter.removeListener('update', listener); console.log('Client disconnected'); }); }); // MCP-like endpoints (adjust to your MCP) app.post('/mcp/start', (req, res) => { targetUrl = req.body.url; if (!targetUrl) { return res.status(400).send({ error: 'URL is required' }); } if (isScraping) { return res.status(400).send({ error: 'Scraping already in progress' }); } isScraping = true; scrapedUrls = []; // Reset scraped URLs scrape(targetUrl); res.send({ message: 'Scraping started' }); }); app.post('/mcp/stop', (req, res) => { isScraping = false; res.send({ message: 'Scraping stopped' }); }); app.get('/mcp/status', (req, res) => { res.send({ isScraping: isScraping, targetUrl: targetUrl, scrapedUrls: scrapedUrls.length }); }); app.listen(port, () => { console.log(`Server listening at http://localhost:${port}`); }); ``` **3. `index.html` (Client-side Example)** ```html <!DOCTYPE html> <html> <head> <title>Playwright SSE Scraper</title> </head> <body> <h1>Playwright SSE Scraper</h1> <label for="url">URL:</label> <input type="text" id="url" value="https://example.com"><br><br> <button id="startButton">Start Scraping</button> <button id="stopButton">Stop Scraping</button> <h2>Status:</h2> <div id="status"></div> <h2>URLs:</h2> <ul id="urls"></ul> <script> const urlInput = document.getElementById('url'); const startButton = document.getElementById('startButton'); const stopButton = document.getElementById('stopButton'); const statusDiv = document.getElementById('status'); const urlsList = document.getElementById('urls'); let eventSource = null; startButton.addEventListener('click', () => { const url = urlInput.value; startScraping(url); }); stopButton.addEventListener('click', () => { stopScraping(); }); function startScraping(url) { fetch('/mcp/start', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ url: url }) }) .then(response => response.json()) .then(data => { console.log(data); connectToSSE(); }) .catch(error => { console.error('Error starting scraping:', error); statusDiv.textContent = `Error starting scraping: ${error}`; }); } function stopScraping() { fetch('/mcp/stop', { method: 'POST' }) .then(response => response.json()) .then(data => { console.log(data); if (eventSource) { eventSource.close(); eventSource = null; } }) .catch(error => { console.error('Error stopping scraping:', error); statusDiv.textContent = `Error stopping scraping: ${error}`; }); } function connectToSSE() { if (eventSource) { eventSource.close(); } eventSource = new EventSource('/events'); eventSource.onmessage = (event) => { const data = JSON.parse(event.data); console.log('Received SSE event:', data); switch (data.type) { case 'status': statusDiv.textContent = data.message; break; case 'urls': data.urls.forEach(url => { const li = document.createElement('li'); li.textContent = url; urlsList.appendChild(li); }); break; case 'error': statusDiv.textContent = `Error: ${data.message}`; break; } }; eventSource.onerror = (error) => { console.error('SSE error:', error); statusDiv.textContent = `SSE error: ${error}`; eventSource.close(); eventSource = null; }; } </script> </body> </html> ``` **Explanation** * **`server.js`:** * Sets up an Express.js server. * Uses `playwright` to launch a Chromium browser and navigate to the target URL. * `extractUrls()` uses `page.evaluate()` to run JavaScript code within the browser context to extract all `href` attributes from `<a>` tags. * The `/events` endpoint sets up the SSE connection. It sends updates as `data: JSON.stringify(data)\n\n`. * The `/mcp/start` endpoint receives the target URL, starts the Playwright scraping process, and resets the `scrapedUrls` array. * The `/mcp/stop` endpoint sets `isScraping` to `false`, which will stop the scraping loop. * The `/mcp/status` endpoint provides the current status of the scraper. * The `scrape()` function is recursive. It extracts URLs, scrolls down (to load more content), waits, and then calls itself again if `isScraping` is still true. This creates a continuous scraping loop. * Error handling is included to catch Playwright errors and send error messages via SSE. * The `EventEmitter` is used to manage SSE updates. * **`index.html`:** * Provides a simple user interface with a URL input, start/stop buttons, a status display, and a list to show the extracted URLs. * Uses JavaScript to: * Send POST requests to `/mcp/start` and `/mcp/stop` to control the scraping process. * Connect to the `/events` SSE endpoint using `EventSource`. * Update the UI based on the SSE messages received from the server. **How to Run** 1. Save the code as `server.js` and `index.html` in your `playwright-sse-scraper` directory. 2. Run `node server.js` in your terminal. 3. Open `index.html` in your web browser (usually `http://localhost:3000`). 4. Enter a URL in the input field and click "Start Scraping." 5. Click "Stop Scraping" to halt the process. **Important Considerations and Improvements** * **Error Handling:** The error handling in the example is basic. You should add more robust error handling, logging, and retry mechanisms. * **Rate Limiting:** Be very careful not to overload the target website. Implement delays and respect `robots.txt`. Consider using a proxy server to avoid getting your IP address blocked. * **`robots.txt`:** Always check the `robots.txt` file of the target website to see which pages are allowed to be scraped. Respect the rules. * **Dynamic Content:** If the website uses a lot of JavaScript to load content dynamically, you might need to use `page.waitForSelector()` or `page.waitForTimeout()` to wait for elements to appear before extracting URLs. * **Selectors:** The `document.querySelectorAll('a')` selector is very basic. You might need to use more specific CSS selectors to target the URLs you want to extract. * **Headless Mode:** `headless: true` runs the browser in the background. Set it to `false` for debugging. * **Scalability:** For large-scale scraping, consider using a more robust queueing system (e.g., Redis, RabbitMQ) and running multiple Playwright instances in parallel. * **MCP Integration:** Adapt the `/mcp/*` endpoints to match the specific commands and data format of your MCP system. * **Data Storage:** Instead of just displaying the URLs in the browser, you'll likely want to store them in a database or file. * **Authentication:** If the target website requires authentication, you'll need to handle login using Playwright. * **Legal and Ethical Considerations:** Make sure you have the right to scrape the website. Be transparent about your scraping activities. Don't scrape personal information without consent. This comprehensive example should give you a solid foundation for building your Playwright-based URL scraper with SSE and Node.js. Remember to adapt the code to your specific needs and always be ethical and responsible when scraping websites.

Spotify MCP Node Server

Enables AI assistants to control Spotify playback, manage playlists, search music, and access listening history. Requires Spotify Premium and uses secure OAuth 2.0 with PKCE authentication.

Firebase Live MCP Server

Enables querying and management of live Firebase projects, providing access to Firestore collections and documents. It also allows users to retrieve and filter Cloud Function logs directly through the Model Context Protocol.

stackzero-labs/mcp

A model context protocol server that enables applications to use stackzero-labs/ui components through the MCP protocol, supporting both standalone operation and integration with Claude Desktop and Cursor.

MCP Multi-Server System

A dual-server MCP system with PostgreSQL integration that provides financial tools (stock prices, portfolio calculation, financial news) on one server and utility tools (weather, time, data processing, text analysis) on another server.

MCPDemo - Visual SQL Chat Platform

An AI-driven data visualization and SQL chat platform that enables natural language to SQL conversion, interactive chart generation, and database querying through a comprehensive MCP interface. Supports multiple databases, intelligent chart recommendations, and secure data management with temporary link sharing.

Planning Data GOV.UK MCP Server

Auto-generated Model Context Protocol server that provides an interface to the planning.data.gov.uk API, allowing users to interact with UK planning data resources through natural language commands.

MCP-server-using-python

Kami sedang membangun server MCP lokal bernama mix_server, sebuah koneksi yang berfungsi ke Claude untuk desktop sehingga Anda dapat berbicara dengan alat Anda melalui bahasa alami.

Gitea MCP Tool

Enables AI assistants to interact with Gitea repositories through intelligent tools for issue/PR management, workflow analysis, compliance checking, and content generation, plus 200+ CLI commands for complete CRUD operations.

MyFitnessPal MCP Server

Enables retrieval and analysis of MyFitnessPal nutrition data including daily summaries, meal breakdowns, exercise tracking, and macro/micronutrient analysis. Uses browser cookie authentication to access your personal MyFitnessPal account data through natural language queries.

Yandex Search MCP Server

Enables AI assistants to perform real-time web searches and retrieve AI-generated answers using the Yandex Search API. It provides tools for accessing up-to-date internet information with support for both raw search results and summarized content via the Yazeka model.

YouTube Knowledge MCP

Transforms YouTube into a queryable knowledge source with search, video details, transcript analysis, and AI-powered tools for summaries, learning paths, and knowledge graphs. Features quota-aware API access with caching and optional OpenAI/Anthropic integration for advanced content analysis.

Playwright Testing Framework

otomatisasi_pengujian_berbasis_ai_dengan_playwright_cursor_mcp_server

Cloudflare Remote MCP Server Template

A template for deploying MCP servers on Cloudflare Workers without authentication. Enables easy creation and deployment of custom MCP tools that can be accessed remotely via Claude Desktop or Cloudflare AI Playground.

rest-to-mcp

Tentu, berikut adalah tutorial proyek untuk mengonversi REST API menjadi server MCP (Minecraft Protocol): **Penting:** Proyek ini cukup kompleks dan membutuhkan pemahaman tentang REST API, protokol Minecraft, pemrograman jaringan, dan bahasa pemrograman (contoh ini akan menggunakan Python). **Tujuan:** * Mengambil data dari REST API. * Mengubah data tersebut menjadi format yang dapat dipahami oleh klien Minecraft. * Mengirim data tersebut ke klien Minecraft melalui protokol MCP. **Langkah-langkah:** **1. Persiapan Lingkungan:** * **Bahasa Pemrograman:** Pilih bahasa pemrograman. Python sangat direkomendasikan karena memiliki banyak pustaka untuk bekerja dengan REST API dan jaringan. * **Pustaka:** Instal pustaka yang diperlukan: * `requests` (untuk berinteraksi dengan REST API) * `nbt` (untuk bekerja dengan format NBT, yang digunakan oleh Minecraft) * `struct` (untuk mengemas dan membongkar data biner) * `asyncio` (untuk pemrograman asinkron, opsional tapi direkomendasikan untuk kinerja) * `websockets` (jika Anda ingin menggunakan WebSocket untuk komunikasi) ```bash pip install requests nbt asyncio websockets ``` * **Minecraft Server (Opsional):** Anda mungkin memerlukan server Minecraft lokal untuk pengujian. **2. Memahami REST API:** * **Dokumentasi:** Pelajari dokumentasi REST API yang ingin Anda gunakan. Pahami: * Endpoint (URL) yang tersedia. * Metode HTTP (GET, POST, dll.) yang digunakan. * Format data yang dikembalikan (biasanya JSON). * Parameter yang diperlukan. * **Contoh:** Buat beberapa permintaan contoh ke API menggunakan `requests` untuk memastikan Anda dapat mengambil data dengan benar. **3. Memahami Protokol Minecraft (MCP):** * **Dokumentasi:** Protokol Minecraft cukup kompleks. Anda dapat menemukan dokumentasi di wiki Minecraft atau sumber daya online lainnya. Fokus pada: * **Paket:** Bagaimana data dikirim dan diterima dalam paket. * **Format Data:** Bagaimana data dienkode (misalnya, string, integer, NBT). * **Handshaking:** Proses awal koneksi antara klien dan server. * **Keep-Alive:** Mekanisme untuk menjaga koneksi tetap aktif. * **Pustaka:** Pustaka seperti `mcstatus` (Python) dapat membantu Anda memahami dan berinteraksi dengan protokol. **4. Membuat Server MCP:** Berikut adalah kerangka dasar server MCP menggunakan Python dan `asyncio`: ```python import asyncio import websockets import json import requests import struct from nbt import nbt # Konfigurasi REST_API_URL = "https://contoh.api.com/data" # Ganti dengan URL API Anda SERVER_HOST = "localhost" SERVER_PORT = 25565 async def handle_client(websocket, path): try: print(f"Koneksi baru dari {websocket.remote_address}") # 1. Handshaking (Sederhana) # Dalam implementasi nyata, Anda perlu menangani handshaking MCP dengan benar. # Ini adalah contoh yang sangat disederhanakan. await websocket.send("Selamat datang di server MCP!") while True: # 2. Mengambil Data dari REST API try: response = requests.get(REST_API_URL) response.raise_for_status() # Periksa kesalahan HTTP data = response.json() print(f"Data dari API: {data}") except requests.exceptions.RequestException as e: print(f"Kesalahan mengambil data dari API: {e}") await websocket.send(f"Kesalahan API: {e}") await asyncio.sleep(5) # Coba lagi setelah 5 detik continue # 3. Mengonversi Data ke Format Minecraft # Ini adalah bagian yang paling kompleks. Anda perlu mengubah data JSON # menjadi format yang dapat dipahami oleh klien Minecraft. # Contoh ini mengirim data sebagai string JSON. minecraft_data = json.dumps(data) # 4. Mengirim Data ke Klien Minecraft # Anda perlu mengemas data ini ke dalam paket MCP yang benar. # Contoh ini mengirim data sebagai pesan teks. try: await websocket.send(minecraft_data) print(f"Data dikirim ke klien: {minecraft_data}") except websockets.exceptions.ConnectionClosedError: print("Koneksi ke klien ditutup.") break # 5. Jeda await asyncio.sleep(5) # Kirim data setiap 5 detik except Exception as e: print(f"Kesalahan: {e}") finally: print(f"Koneksi ditutup dari {websocket.remote_address}") async def main(): async with websockets.serve(handle_client, SERVER_HOST, SERVER_PORT): print(f"Server MCP berjalan di ws://{SERVER_HOST}:{SERVER_PORT}") await asyncio.Future() # Jalankan server selamanya if __name__ == "__main__": asyncio.run(main()) ``` **Penjelasan Kode:** * **Konfigurasi:** `REST_API_URL`, `SERVER_HOST`, dan `SERVER_PORT` menentukan URL API, alamat server, dan port. * **`handle_client(websocket, path)`:** Fungsi ini menangani setiap koneksi klien. * **Handshaking:** Contoh ini memiliki handshaking yang sangat sederhana. Dalam implementasi nyata, Anda perlu mengimplementasikan handshaking MCP yang benar. * **Mengambil Data:** Menggunakan `requests.get()` untuk mengambil data dari REST API. * **Mengonversi Data:** Bagian ini adalah yang paling kompleks. Anda perlu mengubah data JSON menjadi format yang dapat dipahami oleh klien Minecraft. Contoh ini hanya mengubahnya menjadi string JSON. * **Mengirim Data:** Mengirim data ke klien menggunakan `websocket.send()`. Anda perlu mengemas data ini ke dalam paket MCP yang benar. * **Jeda:** Menunggu 5 detik sebelum mengirim data lagi. * **`main()`:** Memulai server WebSocket. **5. Mengonversi Data ke Format Minecraft:** Ini adalah bagian yang paling menantang. Anda perlu mengubah data JSON dari REST API menjadi format yang dapat dipahami oleh klien Minecraft. Beberapa opsi: * **String:** Kirim data sebagai string JSON. Klien Minecraft dapat membaca string ini dan menampilkannya di layar (misalnya, menggunakan mod). * **NBT:** Gunakan format NBT untuk mengirim data yang lebih kompleks. Anda dapat membuat struktur data NBT yang sesuai dengan data dari API. * **Paket MCP Khusus:** Buat paket MCP khusus untuk mengirim data. Ini membutuhkan pemahaman yang mendalam tentang protokol Minecraft. **Contoh Menggunakan NBT:** ```python from nbt import nbt # ... (Kode sebelumnya) # 3. Mengonversi Data ke Format Minecraft (NBT) nbtfile = nbt.NBTFile() nbtfile['data'] = nbt.TAG_String(json.dumps(data)) # Simpan data JSON sebagai string dalam NBT # 4. Mengirim Data ke Klien Minecraft (NBT) try: # Konversi NBT ke bytes nbt_bytes = nbtfile.write_file(compressed=False) # Jangan kompres untuk kesederhanaan # Kirim panjang data diikuti oleh data NBT length = len(nbt_bytes) await websocket.send(struct.pack(">i", length) + nbt_bytes) # Kirim panjang sebagai integer big-endian print(f"Data NBT dikirim ke klien, panjang: {length}") except websockets.exceptions.ConnectionClosedError: print("Koneksi ke klien ditutup.") break ``` **Penjelasan:** * Membuat objek `NBTFile`. * Menyimpan data JSON sebagai string di dalam tag NBT. * Mengonversi objek NBT menjadi bytes menggunakan `write_file()`. * Mengirim panjang data (sebagai integer) diikuti oleh data NBT. Ini penting agar klien tahu berapa banyak data yang harus dibaca. **6. Membuat Mod Minecraft (Klien):** Anda memerlukan mod Minecraft untuk menerima dan memproses data yang dikirim oleh server MCP. Mod ini harus: * **Terhubung ke Server MCP:** Gunakan pustaka jaringan untuk terhubung ke server WebSocket. * **Menerima Data:** Menerima data dari server. * **Memproses Data:** Mengurai data (misalnya, string JSON atau NBT). * **Menampilkan Data:** Menampilkan data di layar (misalnya, menggunakan GUI). **Contoh Sederhana (Menggunakan string JSON):** ```java // Contoh kode Java untuk mod Minecraft (sangat disederhanakan) import net.minecraft.client.Minecraft; import net.minecraft.util.text.StringTextComponent; import java.net.URI; import org.java_websocket.client.WebSocketClient; import org.java_websocket.handshake.ServerHandshake; public class MyWebSocketClient extends WebSocketClient { public MyWebSocketClient(URI serverURI) { super(serverURI); } @Override public void onOpen(ServerHandshake handshakedata) { System.out.println("Koneksi ke server MCP dibuka."); } @Override public void onMessage(String message) { // Tampilkan pesan di chat Minecraft Minecraft.getInstance().ingameGUI.getChatGUI().printChatMessage(new StringTextComponent(message)); System.out.println("Menerima pesan dari server: " + message); } @Override public void onClose(int code, String reason, boolean remote) { System.out.println("Koneksi ke server MCP ditutup. Kode: " + code + ", Alasan: " + reason); } @Override public void onError(Exception ex) { System.err.println("Terjadi kesalahan: " + ex.getMessage()); ex.printStackTrace(); } public static void main(String[] args) { try { URI uri = new URI("ws://localhost:25565"); // Ganti dengan alamat server Anda MyWebSocketClient client = new MyWebSocketClient(uri); client.connect(); } catch (Exception e) { e.printStackTrace(); } } } ``` **Penjelasan:** * Kode ini menggunakan pustaka `org.java_websocket` untuk membuat klien WebSocket. * `onMessage()` dipanggil ketika server mengirim pesan. * Pesan ditampilkan di chat Minecraft menggunakan `Minecraft.getInstance().ingameGUI.getChatGUI().printChatMessage()`. **7. Pengujian dan Debugging:** * Jalankan server MCP. * Jalankan Minecraft dengan mod yang terpasang. * Pastikan mod terhubung ke server MCP. * Periksa apakah data dari REST API ditampilkan dengan benar di Minecraft. * Gunakan alat debugging untuk mengidentifikasi dan memperbaiki kesalahan. **Tantangan dan Pertimbangan:** * **Kompleksitas Protokol Minecraft:** Protokol Minecraft sangat kompleks. Memahami dan mengimplementasikan protokol dengan benar membutuhkan waktu dan usaha. * **Kinerja:** Mengirim data terlalu sering dapat memengaruhi kinerja Minecraft. Optimalkan kode Anda untuk meminimalkan dampak kinerja. * **Keamanan:** Pastikan server MCP Anda aman. Jangan mengekspos informasi sensitif. * **Skalabilitas:** Jika Anda berencana untuk mendukung banyak klien, Anda perlu mempertimbangkan skalabilitas server MCP Anda. * **Versi Minecraft:** Protokol Minecraft berubah dari waktu ke waktu. Pastikan mod dan server MCP Anda kompatibel dengan versi Minecraft yang Anda gunakan. **Kesimpulan:** Mengonversi REST API menjadi server MCP adalah proyek yang menantang tetapi bermanfaat. Ini membutuhkan pemahaman tentang REST API, protokol Minecraft, pemrograman jaringan, dan bahasa pemrograman. Dengan perencanaan yang matang dan implementasi yang cermat, Anda dapat membuat server MCP yang memungkinkan Anda untuk mengintegrasikan data dari REST API ke dalam Minecraft. **Catatan:** * Ini adalah tutorial proyek dasar. Anda mungkin perlu menyesuaikan kode agar sesuai dengan kebutuhan spesifik Anda. * Ada banyak sumber daya online yang tersedia untuk membantu Anda mempelajari lebih lanjut tentang REST API, protokol Minecraft, dan pemrograman jaringan. * Jangan ragu untuk bertanya jika Anda memiliki pertanyaan.

CST MCP

An MCP server that integrates CST Studio Suite with the Model Context Protocol to enable automated electromagnetic simulation workflows. It provides specialized tools for material definition management and direct interaction with the CST Studio Suite environment.

Angular MCP Toolkit

Provides 11 powerful tools for Angular development with enterprise-grade templates, scaffolding capabilities, and project generation features for modern Angular 20.0.x applications.

SBA MCP Server

Provides access to SBA small business size standards and SBIR/STTR federal R\&D funding data. It enables users to look up NAICS thresholds, verify business eligibility, and search for specific firms or award records across various federal agencies.

QMT-MCP-Server

Mirror of

FireScrape MCP Server

Enables AI models to search the web using DuckDuckGo, scrape webpage content in markdown format, and browse/read local files for code analysis and debugging.

MCP Web Extractor

MCP server that extracts web content using Readability.js

DAV MCP Server

A Model Context Protocol server that allows users to interact with their CalDAV, CardDAV, and WebDAV services (calendars, contacts, and files) from Fastmail and Apple iCloud accounts.