microsoft--mcp-for-beginners/translations/id/03-GettingStarted/05-stdio-server/README.md

Server MCP dengan Transport stdio

⚠️ Pembaruan Penting: Mulai dari Spesifikasi MCP 2025-06-18, transport SSE (Server-Sent Events) mandiri telah dihapus dan digantikan oleh transport "Streamable HTTP". Spesifikasi MCP saat ini mendefinisikan dua mekanisme transport utama:

1. stdio - Input/output standar (direkomendasikan untuk server lokal)
2. Streamable HTTP - Untuk server jarak jauh yang mungkin menggunakan SSE secara internal

Pelajaran ini telah diperbarui untuk fokus pada transport stdio, yang merupakan pendekatan yang direkomendasikan untuk sebagian besar implementasi server MCP.

Transport stdio memungkinkan server MCP berkomunikasi dengan klien melalui aliran input dan output standar. Ini adalah mekanisme transport yang paling sering digunakan dan direkomendasikan dalam spesifikasi MCP saat ini, menyediakan cara yang sederhana dan efisien untuk membangun server MCP yang dapat dengan mudah diintegrasikan dengan berbagai aplikasi klien.

Ikhtisar

Pelajaran ini membahas cara membangun dan menggunakan Server MCP menggunakan transport stdio.

Tujuan Pembelajaran

Pada akhir pelajaran ini, Anda akan dapat:

• Membangun Server MCP menggunakan transport stdio.
• Debug Server MCP menggunakan Inspector.
• Menggunakan Server MCP menggunakan Visual Studio Code.
• Memahami mekanisme transport MCP saat ini dan alasan stdio direkomendasikan.

Transport stdio - Cara Kerjanya

Transport stdio adalah salah satu dari dua tipe transport yang didukung dalam spesifikasi MCP saat ini (2025-11-25). Berikut cara kerjanya:

• Komunikasi Sederhana: Server membaca pesan JSON-RPC dari input standar (stdin) dan mengirim pesan ke output standar (stdout).
• Berbasis proses: Klien menjalankan server MCP sebagai proses anak.
• Format Pesan: Pesan berupa permintaan, notifikasi, atau respons JSON-RPC yang dipisahkan oleh baris baru.
• Logging: Server BOLEH menulis string UTF-8 ke error standar (stderr) untuk tujuan logging.

Persyaratan Utama:

• Pesan HARUS dipisahkan oleh baris baru dan TIDAK BOLEH berisi baris baru yang tertanam
• Server TIDAK BOLEH menulis apa pun ke stdout yang bukan pesan MCP yang valid
• Klien TIDAK BOLEH menulis apa pun ke stdin server yang bukan pesan MCP yang valid

TypeScript

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server(
  {
    name: "example-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

async function runServer() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

runServer().catch(console.error);

Dalam kode sebelumnya:

• Kita mengimpor kelas Server dan StdioServerTransport dari MCP SDK
• Kita membuat instance server dengan konfigurasi dan kapabilitas dasar
• Kita membuat instance StdioServerTransport dan menghubungkan server dengannya, memungkinkan komunikasi melalui stdin/stdout

Python

import asyncio
import logging
from mcp.server import Server
from mcp.server.stdio import stdio_server

# Buat instansi server
server = Server("example-server")

@server.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

async def main():
    async with stdio_server(server) as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            server.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

Dalam kode sebelumnya kita:

• Membuat instance server menggunakan MCP SDK
• Mendefinisikan alat dengan dekorator
• Menggunakan pengelola konteks stdio_server untuk menangani transport

.NET

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Server;

var builder = Host.CreateApplicationBuilder(args);

builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithTools<Tools>();

builder.Services.AddLogging(logging => logging.AddConsole());

var app = builder.Build();
await app.RunAsync();

Perbedaan utama dengan SSE adalah server stdio:

• Tidak memerlukan pengaturan server web atau endpoint HTTP
• Diluncurkan sebagai proses anak oleh klien
• Berkomunikasi melalui aliran stdin/stdout
• Lebih sederhana untuk diimplementasikan dan di-debug

Latihan: Membuat Server stdio

Untuk membuat server kita, kita harus mengingat dua hal:

• Kita perlu menggunakan server web untuk mengekspos endpoint untuk koneksi dan pesan.

Lab: Membuat server MCP stdio sederhana

Dalam lab ini, kita akan membuat server MCP sederhana menggunakan transport stdio yang direkomendasikan. Server ini akan mengekspos alat yang dapat dipanggil oleh klien menggunakan Model Context Protocol standar.

Prasyarat

• Python 3.8 atau lebih baru
• MCP Python SDK: pip install mcp
• Pemahaman dasar tentang pemrograman async

Mari mulai dengan membuat server MCP stdio pertama kita:

import asyncio
import logging
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types

# Konfigurasikan pencatatan
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Buat server
server = Server("example-stdio-server")

@server.tool()
def calculate_sum(a: int, b: int) -> int:
    """Calculate the sum of two numbers"""
    return a + b

@server.tool() 
def get_greeting(name: str) -> str:
    """Generate a personalized greeting"""
    return f"Hello, {name}! Welcome to MCP stdio server."

async def main():
    # Gunakan transportasi stdio
    async with stdio_server(server) as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            server.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

Perbedaan utama dari pendekatan SSE yang sudah tidak digunakan

Transport Stdio (Standar Saat Ini):

• Model subprocess sederhana - klien menjalankan server sebagai proses anak
• Komunikasi via stdin/stdout menggunakan pesan JSON-RPC
• Tidak memerlukan pengaturan server HTTP
• Kinerja dan keamanan lebih baik
• Debugging dan pengembangan lebih mudah

Transport SSE (Dihapus sejak MCP 2025-06-18):

• Memerlukan server HTTP dengan endpoint SSE
• Pengaturan lebih kompleks dengan infrastruktur server web
• Pertimbangan keamanan tambahan untuk endpoint HTTP
• Sekarang digantikan oleh Streamable HTTP untuk skenario berbasis web

Membuat server dengan transport stdio

Untuk membuat server stdio kita, kita harus:

1. Impor pustaka yang dibutuhkan - Kita butuh komponen server MCP dan transport stdio
2. Buat instance server - Definisikan server dengan kapabilitasnya
3. Definisikan alat - Tambahkan fungsi yang ingin kita buka
4. Siapkan transport - Konfigurasikan komunikasi stdio
5. Jalankan server - Mulai server dan tangani pesan

Mari kita bangun langkah demi langkah:

Langkah 1: Buat server stdio dasar

import asyncio
import logging
from mcp.server import Server
from mcp.server.stdio import stdio_server

# Konfigurasikan pencatatan
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Buat server
server = Server("example-stdio-server")

@server.tool()
def get_greeting(name: str) -> str:
    """Generate a personalized greeting"""
    return f"Hello, {name}! Welcome to MCP stdio server."

async def main():
    async with stdio_server(server) as (read_stream, write_stream):
        await server.run(
            read_stream,
            write_stream,
            server.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

Langkah 2: Tambahkan lebih banyak alat

@server.tool()
def calculate_sum(a: int, b: int) -> int:
    """Calculate the sum of two numbers"""
    return a + b

@server.tool()
def calculate_product(a: int, b: int) -> int:
    """Calculate the product of two numbers"""
    return a * b

@server.tool()
def get_server_info() -> dict:
    """Get information about this MCP server"""
    return {
        "server_name": "example-stdio-server",
        "version": "1.0.0",
        "transport": "stdio",
        "capabilities": ["tools"]
    }

Langkah 3: Menjalankan server

Simpan kode sebagai server.py dan jalankan dari baris perintah:

python server.py

Server akan mulai dan menunggu input dari stdin. Ia berkomunikasi menggunakan pesan JSON-RPC melalui transport stdio.

Langkah 4: Menguji dengan Inspector

Anda dapat menguji server Anda menggunakan MCP Inspector:

1. Pasang Inspector: npx @modelcontextprotocol/inspector
2. Jalankan Inspector dan arahkan ke server Anda
3. Uji alat yang telah Anda buat

.NET

var builder = WebApplication.CreateBuilder(args);
builder.Services
    .AddMcpServer();

Debug server stdio Anda

Menggunakan MCP Inspector

MCP Inspector adalah alat yang berharga untuk debugging dan pengujian server MCP. Berikut cara menggunakannya dengan server stdio Anda:

1. Instal Inspector:

   npx @modelcontextprotocol/inspector
   

2. Jalankan Inspector:

   npx @modelcontextprotocol/inspector python server.py
   

3. Uji server Anda: Inspector menyediakan antarmuka web di mana Anda dapat:

   • Melihat kapabilitas server
   • Menguji alat dengan parameter yang berbeda
   • Memantau pesan JSON-RPC
   • Debug masalah koneksi

Menggunakan VS Code

Anda juga dapat mendebug server MCP Anda langsung di VS Code:

1. Buat konfigurasi peluncuran di .vscode/launch.json:

   {
     "version": "0.2.0",
     "configurations": [
       {
         "name": "Debug MCP Server",
         "type": "python",
         "request": "launch",
         "program": "server.py",
         "console": "integratedTerminal"
       }
     ]
   }
   

2. Tetapkan breakpoint di kode server Anda

3. Jalankan debugger dan uji dengan Inspector

Tips debugging umum

• Gunakan stderr untuk logging - jangan pernah menulis ke stdout karena khusus untuk pesan MCP
• Pastikan semua pesan JSON-RPC dipisahkan oleh baris baru
• Uji dengan alat sederhana dulu sebelum menambah fungsionalitas kompleks
• Gunakan Inspector untuk memverifikasi format pesan

Menggunakan server stdio Anda di VS Code

Setelah Anda membangun server MCP stdio, Anda dapat mengintegrasikannya dengan VS Code untuk menggunakannya dengan Claude atau klien kompatibel MCP lainnya.

Konfigurasi

1. Buat file konfigurasi MCP di %APPDATA%\Claude\claude_desktop_config.json (Windows) atau ~/Library/Application Support/Claude/claude_desktop_config.json (Mac):

   {
     "mcpServers": {
       "example-stdio-server": {
         "command": "python",
         "args": ["path/to/your/server.py"]
       }
     }
   }
   

2. Restart Claude: Tutup dan buka kembali Claude untuk memuat konfigurasi server yang baru.

3. Uji koneksi: Mulai percakapan dengan Claude dan coba gunakan alat server Anda:

   • "Bisakah kamu menyapaku menggunakan alat sapaan?"
   • "Hitung jumlah 15 dan 27"
   • "Apa info server?"

Contoh server stdio TypeScript

Berikut contoh lengkap TypeScript untuk referensi:

#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";

const server = new Server(
  {
    name: "example-stdio-server",
    version: "1.0.0",
  },
  {
    capabilities: {
      tools: {},
    },
  }
);

// Tambahkan alat
server.setRequestHandler(ListToolsRequestSchema, async () => {
  return {
    tools: [
      {
        name: "get_greeting",
        description: "Get a personalized greeting",
        inputSchema: {
          type: "object",
          properties: {
            name: {
              type: "string",
              description: "Name of the person to greet",
            },
          },
          required: ["name"],
        },
      },
    ],
  };
});

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "get_greeting") {
    return {
      content: [
        {
          type: "text",
          text: `Hello, ${request.params.arguments?.name}! Welcome to MCP stdio server.`,
        },
      ],
    };
  } else {
    throw new Error(`Unknown tool: ${request.params.name}`);
  }
});

async function runServer() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

runServer().catch(console.error);

Contoh server stdio .NET

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using ModelContextProtocol.Server;
using System.ComponentModel;

var builder = Host.CreateApplicationBuilder(args);

builder.Services
    .AddMcpServer()
    .WithStdioServerTransport()
    .WithTools<Tools>();

var app = builder.Build();
await app.RunAsync();

[McpServerToolType]
public class Tools
{
    [McpServerTool, Description("Get a personalized greeting")]
    public string GetGreeting(string name)
    {
        return $"Hello, {name}! Welcome to MCP stdio server.";
    }

    [McpServerTool, Description("Calculate the sum of two numbers")]
    public int CalculateSum(int a, int b)
    {
        return a + b;
    }
}

Ringkasan

Dalam pelajaran yang diperbarui ini, Anda telah belajar cara:

• Membangun server MCP menggunakan transport stdio saat ini (pendekatan yang direkomendasikan)
• Memahami mengapa transport SSE dihapus diganti dengan stdio dan Streamable HTTP
• Membuat alat yang dapat dipanggil oleh klien MCP
• Debug server menggunakan MCP Inspector
• Mengintegrasikan server stdio Anda dengan VS Code dan Claude

Transport stdio menyediakan cara yang lebih sederhana, lebih aman, dan lebih cepat untuk membangun server MCP dibandingkan pendekatan SSE yang dihapus. Ini adalah transport yang direkomendasikan untuk sebagian besar implementasi server MCP berdasarkan spesifikasi 2025-06-18.

.NET

1. Mari kita buat beberapa alat terlebih dahulu, untuk ini kita akan membuat file Tools.cs dengan konten berikut:

using System.ComponentModel;
using System.Text.Json;
using ModelContextProtocol.Server;

Latihan: Menguji server stdio Anda

Sekarang setelah Anda membangun server stdio, mari kita uji untuk memastikan ia berfungsi dengan benar.

Prasyarat

1. Pastikan Anda telah memasang MCP Inspector:

   npm install -g @modelcontextprotocol/inspector
   

2. Kode server Anda harus sudah disimpan (misalnya, sebagai server.py)

Pengujian dengan Inspector

1. Mulai Inspector dengan server Anda:

   npx @modelcontextprotocol/inspector python server.py
   

2. Buka antarmuka web: Inspector akan membuka jendela browser yang menampilkan kapabilitas server Anda.

3. Uji alat:

   • Coba alat get_greeting dengan nama yang berbeda
   • Uji alat calculate_sum dengan angka yang bermacam-macam
   • Panggil alat get_server_info untuk melihat metadata server

4. Pantau komunikasi: Inspector menampilkan pesan JSON-RPC yang dipertukarkan antara klien dan server.

Apa yang harus Anda lihat

Ketika server Anda mulai dengan benar, Anda harus melihat:

• Kapabilitas server tercantum di Inspector
• Alat tersedia untuk diuji
• Pertukaran pesan JSON-RPC berhasil
• Respon alat ditampilkan di antarmuka

Masalah umum dan solusinya

Server tidak mau mulai:

• Periksa bahwa semua dependensi sudah terpasang: pip install mcp
• Verifikasi sintaks dan indentasi Python
• Cari pesan error di konsol

Alat tidak muncul:

• Pastikan dekorator @server.tool() ada
• Periksa bahwa fungsi alat didefinisikan sebelum main()
• Verifikasi server sudah dikonfigurasi dengan benar

Masalah koneksi:

• Pastikan server memakai transport stdio dengan benar
• Cek tidak ada proses lain yang mengganggu
• Verifikasi sintaks perintah Inspector

Tugas

Coba kembangkan server Anda dengan lebih banyak kapabilitas. Lihat halaman ini untuk, misalnya, menambahkan alat yang memanggil API. Anda menentukan seperti apa server seharusnya. Selamat bersenang-senang :)

Solusi

Solusi Berikut solusi yang mungkin dengan kode yang bekerja.

Poin Penting

Poin-poin penting dari bab ini adalah sebagai berikut:

• Transport stdio adalah mekanisme yang direkomendasikan untuk server MCP lokal.
• Transport stdio memungkinkan komunikasi mulus antara server MCP dan klien menggunakan aliran input dan output standar.
• Anda dapat menggunakan baik Inspector maupun Visual Studio Code untuk langsung menggunakan server stdio, membuat debugging dan integrasi menjadi mudah.

Contoh

• Java Calculator
• .Net Calculator
• JavaScript Calculator
• TypeScript Calculator
• Python Calculator

Sumber Daya Tambahan

• SSE

Apa Selanjutnya

Langkah Berikutnya

Sekarang setelah Anda belajar membangun server MCP dengan transport stdio, Anda bisa menjelajahi topik yang lebih lanjut:

• Selanjutnya: Streaming HTTP dengan MCP (Streamable HTTP) - Pelajari mekanisme transport lain yang didukung untuk server jarak jauh
• Lanjutan: Praktik Terbaik Keamanan MCP - Terapkan keamanan dalam server MCP Anda
• Produksi: Strategi Deployment - Deploy server Anda untuk penggunaan produksi

Sumber Daya Tambahan

• Spesifikasi MCP 2025-11-25 - Spesifikasi resmi
• Dokumentasi MCP SDK - Referensi SDK untuk semua bahasa
• Contoh Komunitas - Contoh server lebih banyak dari komunitas

---

Penafian: Dokumen ini telah diterjemahkan menggunakan layanan terjemahan AI Co-op Translator. Meskipun kami berupaya untuk mencapai akurasi, harap diketahui bahwa terjemahan otomatis mungkin mengandung kesalahan atau ketidakakuratan. Dokumen asli dalam bahasa aslinya harus dianggap sebagai sumber yang sah. Untuk informasi penting, disarankan menggunakan terjemahan profesional oleh manusia. Kami tidak bertanggung jawab atas kesalahpahaman atau penafsiran yang keliru yang timbul dari penggunaan terjemahan ini.