Discover Awesome MCP Servers

Spec-driven Development MCP Server

Enables AI-guided spec-driven development workflow that transforms ideas into implementation through structured stages: goal collection, requirements gathering in EARS format, technical design documentation, task planning, and systematic code execution.

MCP Pokemon Server

An MCP server implementation that enables users to interact with the PokeAPI to fetch Pokemon information through natural language queries.

ClickUp MCP Server

Provides integration with ClickUp's API, allowing you to retrieve task information and manage ClickUp data through MCP-compatible clients.

Substack MCP Server

Enables interaction with Substack publications through natural conversation, allowing users to create posts with cover images, publish notes, manage content, and retrieve profile information.

Debug MCP Server

Enables AI-powered debugging through structured logging with pattern recognition and intelligent analysis. Allows applications to write structured logs and receive actionable debugging insights based on error patterns and frequency analysis.

Highrise MCP Server by CData

This read-only MCP Server allows you to connect to Highrise data from Claude Desktop through CData JDBC Drivers. Free (beta) read/write servers available at https://www.cdata.com/solutions/mcp

MCP Jira Server

Here are a few ways to interpret "MCP to talk to Jira from cursor" and their Indonesian translations, depending on what "MCP" refers to: **Scenario 1: MCP refers to a specific tool or plugin called "MCP"** * **English:** Use MCP to interact with Jira directly from the Cursor editor. * **Indonesian:** Gunakan MCP untuk berinteraksi dengan Jira langsung dari editor Cursor. **Scenario 2: MCP is an abbreviation for "Minimum Common Platform" or something similar (less likely in this context)** * **English:** Use a minimum common platform (or similar tool) to communicate with Jira from within the Cursor editor. * **Indonesian:** Gunakan platform umum minimum (atau alat serupa) untuk berkomunikasi dengan Jira dari dalam editor Cursor. **Scenario 3: MCP is a typo and you meant "API" or another common term** * **English (assuming you meant API):** Use an API to interact with Jira from the Cursor editor. * **Indonesian (assuming you meant API):** Gunakan API untuk berinteraksi dengan Jira dari editor Cursor. **Scenario 4: General instruction to connect Cursor to Jira** * **English:** Connect Cursor to Jira to manage Jira issues directly from your code editor. * **Indonesian:** Hubungkan Cursor ke Jira untuk mengelola masalah Jira langsung dari editor kode Anda. **To give you the best translation, please clarify what "MCP" means in this context.** Knowing what "MCP" refers to will allow me to provide a more accurate and helpful translation.

mcptut1

Tutorial server dan klien MCP

MCP Installer

Here are a few ways to interpret "MCP server that searches MCP Servers" and their Indonesian translations: **Interpretation 1: A server for the Minecraft Coder Pack (MCP) that helps you find other MCP servers.** * **Indonesian Translation:** Server MCP yang mencari Server MCP lain. * **Alternative Indonesian Translation:** Server untuk Minecraft Coder Pack (MCP) yang membantu Anda menemukan server MCP lainnya. (More explicit) **Interpretation 2: A server that lists and provides information about other Minecraft servers using the Minecraft Coder Pack (MCP).** * **Indonesian Translation:** Server yang mendaftar dan memberikan informasi tentang server Minecraft lain yang menggunakan Minecraft Coder Pack (MCP). **Interpretation 3: A server that is itself an MCP server and also has a search function to find other MCP servers.** * **Indonesian Translation:** Server yang merupakan server MCP dan juga memiliki fungsi pencarian untuk menemukan server MCP lainnya. **Which translation is best depends on the specific context.** If you can provide more information about what the server *does*, I can give you a more accurate and helpful translation.

Stealthee MCP

Enables detection and analysis of pre-public product launches through web search, content extraction, AI-powered scoring, and automated alerting. Provides comprehensive tools for surfacing stealth startup signals before they trend publicly.

MCP MongoDB Integration

Proyek ini mendemonstrasikan integrasi MongoDB dengan Model Context Protocol (MCP) untuk menyediakan kemampuan interaksi database kepada asisten AI.

ピティナニュースMCPサーバー

Here are a few options for translating "MCP Server for PTNA news feeds" into Indonesian, depending on the context: **Option 1 (Most Literal):** * **Server MCP untuk umpan berita PTNA** This is a direct translation and is generally understandable. **Option 2 (Slightly More Natural):** * **Server MCP untuk *feed* berita PTNA** Using the English word "feed" is common in Indonesian tech circles. **Option 3 (If PTNA is an acronym and widely known):** * **Server MCP untuk berita PTNA** If PTNA is a well-known acronym, you can omit "umpan" or "feed" as it's implied. **Option 4 (More descriptive, if needed):** * **Server MCP untuk menyediakan berita dari PTNA** (MCP Server to provide news from PTNA) **Which option is best depends on the audience and the context.** * If you're talking to a technical audience familiar with English terms, Option 2 is fine. * If you want to be as clear as possible, Option 1 or 4 is better. * If PTNA is a very well-known acronym, Option 3 is the most concise. Therefore, I recommend using **Server MCP untuk *feed* berita PTNA** unless you have more context.

Docker Build MCP Server

A TypeScript server that fully implements the Model Context Protocol (MCP) standard, providing API access to Docker CLI operations like build, run, stop, and image management through compatible AI clients.

Story MCP Hub

Menyediakan alat untuk mengelola aset dan lisensi IP, berinteraksi dengan Story Python SDK, dan menangani operasi seperti mencetak token, mendaftarkan IP, dan mengunggah metadata ke IPFS.

MCP TS Quickstart

Okay, here's a guide to creating a build-less TypeScript quickstart for an MCP (presumably Minecraft Protocol) server implementation. This approach prioritizes speed of setup and iteration, sacrificing some performance and type-checking rigor for the sake of simplicity. **Important Considerations:** * **Performance:** Running TypeScript directly without compilation is generally slower than running compiled JavaScript. This is fine for prototyping and small-scale testing, but you'll want to compile to JavaScript for production. * **Type Checking:** While you'll get some type checking from your IDE, you won't have the full, strict type checking that a proper build process provides. This means you might miss errors until runtime. * **Dependencies:** This approach assumes you're using a module system that Node.js understands (CommonJS or ES Modules). We'll use ES Modules for this example. **Steps:** 1. **Project Setup:** * Create a new directory for your project: ```bash mkdir mcp-server-quickstart cd mcp-server-quickstart ``` * Initialize a `package.json` file: ```bash npm init -y ``` * Install TypeScript as a development dependency: ```bash npm install --save-dev typescript @types/node ``` 2. **TypeScript Configuration (tsconfig.json - Optional but Recommended):** While we're aiming for "build-less," a basic `tsconfig.json` can still be helpful for IDE support and some level of type checking. Create a `tsconfig.json` file in your project root: ```json { "compilerOptions": { "target": "es2020", // Or a more recent version "module": "esnext", // Use ES Modules "moduleResolution": "node", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true, "outDir": "dist" // Optional: If you *do* want to compile later }, "include": ["src/**/*"], // Where your TypeScript files are "exclude": ["node_modules"] } ``` * **`target`:** Specifies the ECMAScript target version. `es2020` or later is generally a good choice. * **`module`:** Crucially, set this to `esnext` to use ES Modules. This allows you to use `import` and `export` statements directly. * **`moduleResolution`:** Set to `node` for Node.js-style module resolution. * **`esModuleInterop`:** Important for compatibility between CommonJS and ES Modules. * **`strict`:** Enables strict type checking (recommended for catching errors). * **`skipLibCheck`:** Can speed up type checking by skipping type checking of declaration files. Disable if you encounter type errors in your dependencies. * **`outDir`:** Optional. If you decide to compile later, this specifies the output directory for the compiled JavaScript files. 3. **Create a Source Directory:** ```bash mkdir src ``` 4. **Create Your Server File (e.g., `src/index.ts`):** ```typescript // src/index.ts import net from 'net'; const PORT = 25565; // Default Minecraft port const server = net.createServer((socket) => { console.log('Client connected:', socket.remoteAddress, socket.remotePort); socket.on('data', (data) => { console.log('Received data:', data); // TODO: Implement Minecraft protocol handling here socket.write('Hello from the server!\n'); // Example response }); socket.on('close', () => { console.log('Client disconnected:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Socket error:', err); }); }); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); }); ``` 5. **Run Your Server (Without Compilation):** You can run the TypeScript file directly using `ts-node` (if you install it) or using Node.js with the `--loader` flag. Since we're aiming for build-less, let's use the `--loader` flag. Add this to your `package.json` scripts: ```json { "name": "mcp-server-quickstart", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "node --loader ts-node/esm src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "", "license": "ISC", "devDependencies": { "@types/node": "^20.11.19", "typescript": "^5.4.0-dev.20240320" } } ``` Then, run: ```bash npm start ``` **Explanation of `node --loader ts-node/esm src/index.ts`:** * `node`: Executes the Node.js runtime. * `--loader ts-node/esm`: This is the key part. It tells Node.js to use `ts-node/esm` as a module loader. `ts-node/esm` is a special version of `ts-node` that supports ES Modules. It will dynamically compile your TypeScript code in memory and execute it. * `src/index.ts`: The entry point to your application. 6. **Install `ts-node` (Alternative):** If you prefer, you can install `ts-node` globally or locally: ```bash npm install -g ts-node # Globally (not recommended for project-specific dependencies) npm install --save-dev ts-node # Locally ``` If you install it locally, you'll need to adjust your `package.json` script: ```json { "scripts": { "start": "ts-node src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" } } ``` Then run `npm start`. **Explanation and Next Steps:** * **Basic Server:** The code creates a simple TCP server that listens on port 25565 (the default Minecraft port). It logs client connections, receives data, and sends a basic response. * **Minecraft Protocol:** The `// TODO: Implement Minecraft protocol handling here` comment is where you'll need to add the logic to parse and handle the Minecraft protocol. This is the most complex part of building an MCP server. You'll need to understand the protocol specification. Libraries exist to help with this (see below). * **Error Handling:** The code includes basic error handling for socket errors. You'll want to expand this to handle other potential errors. * **Asynchronous Operations:** Minecraft protocol handling often involves asynchronous operations (e.g., reading data from the socket). Use `async/await` to make your code more readable. **Libraries to Consider:** * **`prismarine-protocol`:** A popular library for parsing and handling the Minecraft protocol. It's part of the PrismarineJS project. This is *highly* recommended. * **`node-raknet`:** If you're dealing with Bedrock Edition, you'll need to handle the RakNet protocol. **Example using `prismarine-protocol` (Illustrative - Requires Installation):** First, install the library: ```bash npm install prismarine-protocol ``` Then, modify your `src/index.ts` (this is a simplified example): ```typescript import net from 'net'; import { createSerializer, createDeserializer } from 'prismarine-protocol'; const PORT = 25565; const server = net.createServer((socket) => { console.log('Client connected:', socket.remoteAddress, socket.remotePort); const serializer = createSerializer({ version: '1.19.4' }); // Replace with the correct version const deserializer = createDeserializer({ version: '1.19.4' }); socket.on('data', (data) => { deserializer.write(data); let packet; while ((packet = deserializer.read())) { console.log('Received packet:', packet); // Example: Respond to a handshake packet if (packet.name === 'handshake') { const response = { version_name: 'My Server', protocol_version: packet.data.protocol_version, max_players: 100, online_players: 0, sample: [], description: { text: 'A TypeScript MCP Server' }, favicon: null, }; serializer.write('status', response); const statusPacket = serializer.read(); if (statusPacket) { socket.write(statusPacket); } } } }); socket.on('close', () => { console.log('Client disconnected:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Socket error:', err); }); }); server.listen(PORT, () => { console.log(`Server listening on port ${PORT}`); }); ``` **Important Notes about the `prismarine-protocol` Example:** * **Version:** You *must* specify the correct Minecraft protocol version when creating the serializer and deserializer. The example uses `'1.19.4'`. Use the version that your server is intended to support. Incorrect versions will lead to parsing errors. * **Packet Handling:** The example shows how to read packets using `deserializer.read()`. You'll need to implement logic to handle different packet types based on the Minecraft protocol specification. * **Status Response:** The example shows how to respond to a handshake packet with a status response. This is a basic example; you'll need to implement the full status response according to the protocol. * **Error Handling:** `prismarine-protocol` can throw errors if it encounters invalid data. Wrap your `deserializer.read()` calls in a `try...catch` block to handle these errors gracefully. * **Buffering:** The `deserializer` might not have enough data to parse a complete packet. It buffers the data internally. The `while ((packet = deserializer.read()))` loop ensures that you process all available packets. **Moving to Production:** When you're ready to deploy your server to production, you *must* compile your TypeScript code to JavaScript. Use the `tsc` command: ```bash tsc ``` This will create JavaScript files in the `outDir` specified in your `tsconfig.json` (or the current directory if you don't have an `outDir`). Then, you can run the JavaScript files using Node.js: ```bash node dist/index.js // Assuming your output directory is "dist" ``` **Summary:** This guide provides a quick way to get started with a TypeScript MCP server implementation without a full build process. Remember that this approach is best for prototyping and small-scale testing. For production deployments, you should always compile your TypeScript code to JavaScript. Use libraries like `prismarine-protocol` to simplify the process of handling the Minecraft protocol. Good luck! **Indonesian Translation:** Oke, berikut adalah panduan untuk membuat *quickstart* TypeScript tanpa proses *build* untuk implementasi server MCP (kemungkinan besar Minecraft Protocol). Pendekatan ini memprioritaskan kecepatan pengaturan dan iterasi, mengorbankan beberapa kinerja dan ketelitian pemeriksaan tipe demi kesederhanaan. **Pertimbangan Penting:** * **Kinerja:** Menjalankan TypeScript secara langsung tanpa kompilasi umumnya lebih lambat daripada menjalankan JavaScript yang telah dikompilasi. Ini tidak masalah untuk pembuatan prototipe dan pengujian skala kecil, tetapi Anda perlu mengkompilasi ke JavaScript untuk produksi. * **Pemeriksaan Tipe:** Meskipun Anda akan mendapatkan beberapa pemeriksaan tipe dari IDE Anda, Anda tidak akan memiliki pemeriksaan tipe yang lengkap dan ketat seperti yang disediakan oleh proses *build* yang tepat. Ini berarti Anda mungkin melewatkan kesalahan hingga *runtime*. * **Dependensi:** Pendekatan ini mengasumsikan Anda menggunakan sistem modul yang dipahami oleh Node.js (CommonJS atau ES Modules). Kita akan menggunakan ES Modules untuk contoh ini. **Langkah-langkah:** 1. **Pengaturan Proyek:** * Buat direktori baru untuk proyek Anda: ```bash mkdir mcp-server-quickstart cd mcp-server-quickstart ``` * Inisialisasi file `package.json`: ```bash npm init -y ``` * Instal TypeScript sebagai dependensi pengembangan: ```bash npm install --save-dev typescript @types/node ``` 2. **Konfigurasi TypeScript (tsconfig.json - Opsional tetapi Disarankan):** Meskipun kita bertujuan untuk "tanpa *build*," `tsconfig.json` dasar masih dapat membantu untuk dukungan IDE dan beberapa tingkat pemeriksaan tipe. Buat file `tsconfig.json` di *root* proyek Anda: ```json { "compilerOptions": { "target": "es2020", // Atau versi yang lebih baru "module": "esnext", // Gunakan ES Modules "moduleResolution": "node", "esModuleInterop": true, "forceConsistentCasingInFileNames": true, "strict": true, "skipLibCheck": true, "outDir": "dist" // Opsional: Jika Anda *ingin* mengkompilasi nanti }, "include": ["src/**/*"], // Di mana file TypeScript Anda berada "exclude": ["node_modules"] } ``` * **`target`:** Menentukan versi ECMAScript target. `es2020` atau yang lebih baru umumnya merupakan pilihan yang baik. * **`module`:** Sangat penting, atur ini ke `esnext` untuk menggunakan ES Modules. Ini memungkinkan Anda menggunakan pernyataan `import` dan `export` secara langsung. * **`moduleResolution`:** Atur ke `node` untuk resolusi modul gaya Node.js. * **`esModuleInterop`:** Penting untuk kompatibilitas antara CommonJS dan ES Modules. * **`strict`:** Mengaktifkan pemeriksaan tipe yang ketat (disarankan untuk menangkap kesalahan). * **`skipLibCheck`:** Dapat mempercepat pemeriksaan tipe dengan melewati pemeriksaan tipe file deklarasi. Nonaktifkan jika Anda menemukan kesalahan tipe dalam dependensi Anda. * **`outDir`:** Opsional. Jika Anda memutuskan untuk mengkompilasi nanti, ini menentukan direktori keluaran untuk file JavaScript yang dikompilasi. 3. **Buat Direktori Sumber:** ```bash mkdir src ``` 4. **Buat File Server Anda (misalnya, `src/index.ts`):** ```typescript // src/index.ts import net from 'net'; const PORT = 25565; // Port Minecraft default const server = net.createServer((socket) => { console.log('Klien terhubung:', socket.remoteAddress, socket.remotePort); socket.on('data', (data) => { console.log('Data diterima:', data); // TODO: Implementasikan penanganan protokol Minecraft di sini socket.write('Halo dari server!\n'); // Contoh respons }); socket.on('close', () => { console.log('Klien terputus:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Kesalahan socket:', err); }); }); server.listen(PORT, () => { console.log(`Server mendengarkan di port ${PORT}`); }); ``` 5. **Jalankan Server Anda (Tanpa Kompilasi):** Anda dapat menjalankan file TypeScript secara langsung menggunakan `ts-node` (jika Anda menginstalnya) atau menggunakan Node.js dengan *flag* `--loader`. Karena kita bertujuan untuk tanpa *build*, mari gunakan *flag* `--loader`. Tambahkan ini ke skrip `package.json` Anda: ```json { "name": "mcp-server-quickstart", "version": "1.0.0", "description": "", "main": "index.js", "scripts": { "start": "node --loader ts-node/esm src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" }, "keywords": [], "author": "", "license": "ISC", "devDependencies": { "@types/node": "^20.11.19", "typescript": "^5.4.0-dev.20240320" } } ``` Kemudian, jalankan: ```bash npm start ``` **Penjelasan `node --loader ts-node/esm src/index.ts`:** * `node`: Mengeksekusi *runtime* Node.js. * `--loader ts-node/esm`: Ini adalah bagian penting. Ini memberi tahu Node.js untuk menggunakan `ts-node/esm` sebagai *module loader*. `ts-node/esm` adalah versi khusus dari `ts-node` yang mendukung ES Modules. Ini akan secara dinamis mengkompilasi kode TypeScript Anda dalam memori dan mengeksekusinya. * `src/index.ts`: Titik masuk ke aplikasi Anda. 6. **Instal `ts-node` (Alternatif):** Jika Anda lebih suka, Anda dapat menginstal `ts-node` secara global atau lokal: ```bash npm install -g ts-node # Secara global (tidak disarankan untuk dependensi khusus proyek) npm install --save-dev ts-node # Secara lokal ``` Jika Anda menginstalnya secara lokal, Anda perlu menyesuaikan skrip `package.json` Anda: ```json { "scripts": { "start": "ts-node src/index.ts", "test": "echo \"Error: no test specified\" && exit 1" } } ``` Kemudian jalankan `npm start`. **Penjelasan dan Langkah Selanjutnya:** * **Server Dasar:** Kode membuat server TCP sederhana yang mendengarkan di port 25565 (port Minecraft default). Ini mencatat koneksi klien, menerima data, dan mengirim respons dasar. * **Protokol Minecraft:** Komentar `// TODO: Implementasikan penanganan protokol Minecraft di sini` adalah tempat Anda perlu menambahkan logika untuk mengurai dan menangani protokol Minecraft. Ini adalah bagian paling kompleks dari membangun server MCP. Anda perlu memahami spesifikasi protokol. Pustaka ada untuk membantu dengan ini (lihat di bawah). * **Penanganan Kesalahan:** Kode menyertakan penanganan kesalahan dasar untuk kesalahan *socket*. Anda perlu memperluas ini untuk menangani potensi kesalahan lainnya. * **Operasi Asinkron:** Penanganan protokol Minecraft sering melibatkan operasi asinkron (misalnya, membaca data dari *socket*). Gunakan `async/await` untuk membuat kode Anda lebih mudah dibaca. **Pustaka yang Perlu Dipertimbangkan:** * **`prismarine-protocol`:** Pustaka populer untuk mengurai dan menangani protokol Minecraft. Ini adalah bagian dari proyek PrismarineJS. Ini *sangat* direkomendasikan. * **`node-raknet`:** Jika Anda berurusan dengan Bedrock Edition, Anda perlu menangani protokol RakNet. **Contoh menggunakan `prismarine-protocol` (Ilustratif - Membutuhkan Instalasi):** Pertama, instal pustaka: ```bash npm install prismarine-protocol ``` Kemudian, modifikasi `src/index.ts` Anda (ini adalah contoh yang disederhanakan): ```typescript import net from 'net'; import { createSerializer, createDeserializer } from 'prismarine-protocol'; const PORT = 25565; const server = net.createServer((socket) => { console.log('Klien terhubung:', socket.remoteAddress, socket.remotePort); const serializer = createSerializer({ version: '1.19.4' }); // Ganti dengan versi yang benar const deserializer = createDeserializer({ version: '1.19.4' }); socket.on('data', (data) => { deserializer.write(data); let packet; while ((packet = deserializer.read())) { console.log('Paket diterima:', packet); // Contoh: Menanggapi paket handshake if (packet.name === 'handshake') { const response = { version_name: 'My Server', protocol_version: packet.data.protocol_version, max_players: 100, online_players: 0, sample: [], description: { text: 'A TypeScript MCP Server' }, favicon: null, }; serializer.write('status', response); const statusPacket = serializer.read(); if (statusPacket) { socket.write(statusPacket); } } } }); socket.on('close', () => { console.log('Klien terputus:', socket.remoteAddress, socket.remotePort); }); socket.on('error', (err) => { console.error('Kesalahan socket:', err); }); }); server.listen(PORT, () => { console.log(`Server mendengarkan di port ${PORT}`); }); ``` **Catatan Penting tentang Contoh `prismarine-protocol`:** * **Versi:** Anda *harus* menentukan versi protokol Minecraft yang benar saat membuat *serializer* dan *deserializer*. Contohnya menggunakan `'1.19.4'`. Gunakan versi yang ingin didukung oleh server Anda. Versi yang salah akan menyebabkan kesalahan penguraian. * **Penanganan Paket:** Contoh menunjukkan cara membaca paket menggunakan `deserializer.read()`. Anda perlu mengimplementasikan logika untuk menangani berbagai jenis paket berdasarkan spesifikasi protokol Minecraft. * **Respons Status:** Contoh menunjukkan cara menanggapi paket *handshake* dengan respons status. Ini adalah contoh dasar; Anda perlu mengimplementasikan respons status lengkap sesuai dengan protokol. * **Penanganan Kesalahan:** `prismarine-protocol` dapat memunculkan kesalahan jika menemukan data yang tidak valid. Bungkus panggilan `deserializer.read()` Anda dalam blok `try...catch` untuk menangani kesalahan ini dengan baik. * **Buffering:** `deserializer` mungkin tidak memiliki cukup data untuk mengurai paket lengkap. Ini *buffer* data secara internal. Loop `while ((packet = deserializer.read()))` memastikan bahwa Anda memproses semua paket yang tersedia. **Pindah ke Produksi:** Saat Anda siap untuk menyebarkan server Anda ke produksi, Anda *harus* mengkompilasi kode TypeScript Anda ke JavaScript. Gunakan perintah `tsc`: ```bash tsc ``` Ini akan membuat file JavaScript di `outDir` yang ditentukan dalam `tsconfig.json` Anda (atau direktori saat ini jika Anda tidak memiliki `outDir`). Kemudian, Anda dapat menjalankan file JavaScript menggunakan Node.js: ```bash node dist/index.js // Asumsikan direktori keluaran Anda adalah "dist" ``` **Ringkasan:** Panduan ini menyediakan cara cepat untuk memulai implementasi server MCP TypeScript tanpa proses *build* lengkap. Ingatlah bahwa pendekatan ini paling baik untuk pembuatan prototipe dan pengujian skala kecil. Untuk penyebaran produksi, Anda harus selalu mengkompilasi kode TypeScript Anda ke JavaScript. Gunakan pustaka seperti `prismarine-protocol` untuk menyederhanakan proses penanganan protokol Minecraft. Semoga berhasil!

서울시 교통 데이터 MCP 서버

서울시 교통 데이터 MCP 서버 - 실시간 교통 정보, 대중교통, 따릉이 등의 데이터를 제공하는 MCP 서버

Omni Server

Server MCP untuk membiasakan diri dengan Model Context Protocol

Domain Check MCP Server

Berikut adalah terjemahan dari teks tersebut ke dalam bahasa Indonesia: **Server Protokol Konteks Model (MCP) untuk memeriksa ketersediaan domain menggunakan titik akhir IONOS**

Elasticsearch MCP Server by CData

Elasticsearch MCP Server by CData

Image Converter MCP Server

Enables conversion between multiple image formats including JPG, PNG, WebP, GIF, BMP, TIFF, SVG, ICO, and AVIF with quality control and batch processing capabilities.

mcp-google-sheets

Google Spreadsheet.

Optimizely DXP MCP Server

Enables AI assistants to manage Optimizely DXP deployments through natural language conversations. Supports code deployment, database operations, content synchronization, and environment management across Integration, Preproduction, and Production environments.

Google Drive HPC Log Analyzer

Enables Claude to directly access Google Drive files and analyze High Performance Computing (HPC) log files. Automatically detects common HPC issues like memory errors, job timeouts, and resource allocation problems.

Filesystem MCP Server (@shtse8/filesystem-mcp)

Server Node.js Model Context Protocol (MCP) yang menyediakan akses sistem berkas yang aman dan relatif untuk agen AI seperti Cline/Claude.

Browse Together MCP

Bekerja bersama (co-browse) dengan AI Anda saat Anda mengedit kode. Sebuah browser berkepala yang dikendalikan oleh Playwright dengan server MCP yang menyertainya.

Aseprite MCP Tools

Server MCP untuk berinteraksi dengan Aseprite API

Finance MCP Server

Server MCP minimal yang dibangun dengan Python yang menyediakan dua contoh alat: satu untuk mengubah nama perusahaan menjadi simbol saham, dan yang lainnya untuk mengambil data keuangan dari Yahoo Finance. Proyek ini berfokus pada pembelajaran cara membangun dan menjalankan server MCP—menggunakan skenario keuangan sederhana murni sebagai contoh kasus penggunaan.