Ikhtisar

MCP menawarkan tiga opsi transport, masing-masing cocok untuk skenario deployment yang berbeda:

STDIO transport (server lokal)
Streamable HTTP transport (standar modern untuk server remote)
SSE transport (opsi remote legacy)

Setiap transport memiliki karakteristik, keunggulan, dan use case yang berbeda.

STDIO transport

STDIO transport berjalan secara lokal di mesinmu dan berkomunikasi melalui stream standard input/output.

Cara kerja STDIO transport

Bob men-spawn MCP server sebagai child process
Komunikasi terjadi melalui stream proses: Bob menulis ke STDIN server, server merespons ke STDOUT
Setiap pesan dibatasi oleh karakter newline
Pesan diformat sebagai JSON-RPC 2.0

Client                    Server
  |                         |
  |---- JSON message ------>| (via STDIN)
  |                         | (processes request)
  |<---- JSON message ------| (via STDOUT)
  |                         |

Karakteristik STDIO

Lokalitas: Berjalan di mesin yang sama dengan Bob
Performa: Latensi sangat rendah (tidak melibatkan network stack)
Kesederhanaan: Komunikasi proses langsung tanpa konfigurasi jaringan
Relasi: Hubungan satu-ke-satu antara klien dan server
Keamanan: Secara inheren lebih aman tanpa eksposur jaringan

Kapan menggunakan STDIO

STDIO transport ideal untuk:

Integrasi lokal dan tools yang berjalan di mesin yang sama
Operasi yang sensitif terhadap keamanan
Persyaratan latensi rendah
Skenario single-client (satu instance Bob per server)
Tools command-line atau IDE extension

Contoh implementasi STDIO


const server = new Server({name: 'local-server', version: '1.0.0'});
// Register tools...

// Use STDIO transport
const transport = new StdioServerTransport(server);
transport.listen();

Streamable HTTP transport adalah standar modern untuk komunikasi MCP server remote, menggantikan transport HTTP+SSE yang lebih lama. Beroperasi melalui HTTP/HTTPS dan memungkinkan implementasi server yang lebih fleksibel.

Cara kerja Streamable HTTP transport

Server menyediakan satu endpoint HTTP (endpoint MCP) yang mendukung metode POST dan GET
Bob mengirim permintaan ke endpoint MCP ini menggunakan HTTP POST
Server memproses permintaan dan mengirimkan respons kembali
Opsional, server bisa menggunakan Server-Sent Events (SSE) melalui koneksi yang sama untuk streaming beberapa pesan atau notifikasi ke Bob

Ini memungkinkan interaksi request-response dasar maupun streaming yang lebih canggih dan komunikasi yang dimulai oleh server.

Client                             Server
  |                                  |
  |---- HTTP POST /mcp_endpoint ---->| (client request)
  |                                  | (processes request)
  |<--- HTTP Response / SSE Stream --| (server response / stream)
  |                                  |

Karakteristik Streamable HTTP

Standar modern: Metode yang disukai untuk implementasi MCP server remote baru
Akses remote: Bisa di-host di mesin yang berbeda dari Bob
Skalabilitas: Bisa menangani beberapa koneksi klien secara bersamaan
Protokol: Bekerja melalui HTTP/HTTPS standar
Fleksibilitas: Mendukung request-response sederhana dan streaming canggih
Single endpoint: Menggunakan satu jalur URL untuk semua komunikasi MCP
Autentikasi: Bisa menggunakan mekanisme autentikasi HTTP standar
Backwards compatibility: Server bisa mempertahankan kompatibilitas dengan klien HTTP+SSE yang lebih lama

Kapan menggunakan Streamable HTTP

Streamable HTTP transport ideal untuk:

Semua pengembangan MCP server remote baru
Server yang memerlukan komunikasi yang kuat, skalabel, dan fleksibel
Integrasi yang mungkin melibatkan streaming data atau notifikasi yang dikirim server
Layanan publik atau tools terpusat
Menggantikan implementasi transport SSE legacy

Contoh implementasi Streamable HTTP

Konfigurasi di settings.json:

{
  "mcpServers": {
    "StreamableHTTPMCPName": {
      "type": "streamable-http",
      "url": "http://localhost:8080/mcp"
    }
  }
}

Untuk implementasi sisi server, lihat dokumentasi MCP SDK untuk StreamableHTTPClientTransport.

Backwards compatibility dengan HTTP+SSE

Klien dan server bisa mempertahankan backwards compatibility dengan transport HTTP+SSE yang sudah deprecated.

Server yang ingin mendukung klien lama harus terus meng-host endpoint SSE (/events) dan POST (/message) dari transport lama, bersama dengan endpoint MCP baru yang didefinisikan untuk transport Streamable HTTP.

SSE transport (legacy)

Server-Sent Events (SSE) transport berjalan di server remote dan berkomunikasi melalui HTTP/HTTPS. Untuk server remote baru, gunakan Streamable HTTP transport sebagai gantinya.

Cara kerja SSE transport

Bob terhubung ke endpoint SSE server melalui HTTP GET request
Ini membuat koneksi persisten di mana server bisa mem-push event ke Bob
Untuk komunikasi klien-ke-server, Bob membuat HTTP POST request ke endpoint terpisah
Komunikasi terjadi melalui dua channel:
- Event stream (GET): Pembaruan server-ke-klien
- Message endpoint (POST): Permintaan klien-ke-server

Client                             Server
  |                                  |
  |---- HTTP GET /events ----------->| (establish SSE connection)
  |<---- SSE event stream -----------| (persistent connection)
  |                                  |
  |---- HTTP POST /message --------->| (client request)
  |<---- SSE event with response ----| (server response)
  |                                  |

Karakteristik SSE

Akses remote: Bisa di-host di mesin yang berbeda dari Bob
Skalabilitas: Bisa menangani beberapa koneksi klien secara bersamaan
Protokol: Bekerja melalui HTTP standar (tidak perlu protokol khusus)
Persistensi: Mempertahankan koneksi persisten untuk pesan server-ke-klien
Autentikasi: Bisa menggunakan mekanisme autentikasi HTTP standar

Kapan menggunakan SSE

SSE transport cocok untuk:

Akses remote di seluruh jaringan
Skenario multi-klien
Layanan publik
Tools terpusat yang perlu diakses banyak pengguna
Integrasi dengan web service

Contoh implementasi SSE

import express from 'express';

const app = express();
const server = new Server({name: 'remote-server', version: '1.0.0'});
// Register tools...

// Use SSE transport
const transport = new SSEServerTransport(server);
app.use('/mcp', transport.requestHandler());
app.listen(3000, () => {
  console.log('MCP server listening on port 3000');
});

Pertimbangan deployment

Pilihan antara STDIO dan transport remote (Streamable HTTP atau SSE) secara langsung mempengaruhi cara kamu men-deploy dan mengelola MCP server-mu.

STDIO: Deployment lokal

STDIO server berjalan secara lokal di mesin yang sama dengan Bob:

Instalasi: Executable server harus diinstal di setiap mesin pengguna
Distribusi: Kamu perlu menyediakan paket instalasi untuk sistem operasi yang berbeda
Pembaruan: Setiap instance harus diperbarui secara terpisah
Sumber daya: Menggunakan CPU, memori, dan disk mesin lokal
Kontrol akses: Bergantung pada izin file system mesin lokal
Integrasi: Mudah diintegrasikan dengan sumber daya sistem lokal (file, proses)
Eksekusi: Dimulai dan dihentikan bersama Bob (lifecycle child process)
Dependensi: Semua dependensi harus diinstal di mesin pengguna

Contoh use case:

Tool pencarian file lokal menggunakan STDIO akan:

Berjalan di mesin pengguna
Memiliki akses langsung ke file system lokal
Dimulai ketika diperlukan oleh Bob
Tidak memerlukan konfigurasi jaringan
Perlu diinstal bersama Bob atau melalui package manager

Remote: Deployment ter-host

Server remote (Streamable HTTP atau SSE) bisa di-deploy ke server remote dan diakses melalui jaringan:

Instalasi: Diinstal sekali di server, diakses oleh banyak pengguna
Distribusi: Deployment tunggal melayani beberapa klien
Pembaruan: Pembaruan terpusat segera mempengaruhi semua pengguna
Sumber daya: Menggunakan sumber daya server, bukan sumber daya mesin lokal
Kontrol akses: Dikelola melalui sistem autentikasi dan otorisasi
Integrasi: Integrasi yang lebih kompleks dengan sumber daya spesifik pengguna
Eksekusi: Berjalan sebagai layanan independen (sering secara terus-menerus)
Dependensi: Dikelola di server, bukan di mesin pengguna