MCP mendukung mekanisme transport untuk komunikasi antara Bob Shell dan MCP server.

Ikhtisar

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

Transport STDIO (server lokal)

Transport Streamable HTTP (standar modern untuk server remote)

Transport SSE (opsi remote lama)

Setiap transport memiliki karakteristik, keunggulan, dan kasus penggunaan yang berbeda.

Transport STDIO

Transport STDIO berjalan secara lokal di mesin kamu dan berkomunikasi melalui stream input/output standar.

Cara kerja transport STDIO

Bob menjalankan MCP server sebagai proses anak

Komunikasi terjadi melalui stream proses: Bob menulis ke STDIN server, server merespons ke STDOUT

Setiap pesan dibatasi oleh karakter baris baru

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 dan overhead sangat rendah (tidak ada network stack yang terlibat)

Kesederhanaan: Komunikasi proses langsung tanpa konfigurasi jaringan

Hubungan: Hubungan satu-ke-satu antara client dan server

Keamanan: Secara inheren lebih aman tanpa paparan jaringan

Kapan menggunakan STDIO

Transport STDIO ideal untuk:

Integrasi lokal dan alat yang berjalan di mesin yang sama

Operasi sensitif keamanan

Persyaratan latensi rendah

Skenario single-client (satu instance Bob per server)

Alat dan skrip command-line

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();

Transport Streamable HTTP 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 transport Streamable HTTP

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 mengirim kembali respons

Secara opsional, server dapat menggunakan Server-Sent Events (SSE) melalui koneksi yang sama untuk men-stream beberapa pesan atau notifikasi ke Bob

Ini memungkinkan interaksi permintaan-respons dasar serta komunikasi streaming dan yang dimulai server yang lebih canggih.

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: Dapat di-hosting di mesin yang berbeda dari Bob

Skalabilitas: Dapat menangani beberapa koneksi client secara bersamaan

Protokol: Bekerja melalui HTTP/HTTPS standar

Fleksibilitas: Mendukung permintaan-respons sederhana dan streaming canggih

Endpoint tunggal: Menggunakan satu jalur URL untuk semua komunikasi MCP

Autentikasi: Dapat menggunakan mekanisme autentikasi HTTP standar

Kompatibilitas mundur: Server dapat mempertahankan kompatibilitas dengan klien HTTP+SSE yang lebih lama

Kapan menggunakan Streamable HTTP

Transport Streamable HTTP 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 alat terpusat

Menggantikan implementasi transport SSE lama

Contoh implementasi Streamable HTTP

Konfigurasi di ~/.bob/mcp_settings.json (global) atau .bob/mcp.json (proyek):

{
  "mcpServers": {
    "StreamableHTTPMCPName": {
      "httpURL": "http://localhost:8080/mcp"
    }
  }
}

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

Kompatibilitas mundur dengan HTTP+SSE

Client dan server dapat mempertahankan kompatibilitas mundur dengan transport HTTP+SSE yang sudah tidak digunakan.

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

Transport SSE (lama)

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

Cara kerja transport SSE

Bob terhubung ke endpoint SSE server melalui permintaan HTTP GET

Ini membuat koneksi persisten di mana server dapat mendorong event ke Bob

Untuk komunikasi client-ke-server, Bob membuat permintaan HTTP POST ke endpoint terpisah

Komunikasi terjadi melalui dua saluran:

Event stream (GET): Pembaruan server-ke-client
Endpoint pesan (POST): Permintaan client-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: Dapat di-hosting di mesin yang berbeda dari Bob

Skalabilitas: Dapat menangani beberapa koneksi client secara bersamaan

Protokol: Bekerja melalui HTTP standar (tidak diperlukan protokol khusus)

Persistensi: Mempertahankan koneksi persisten untuk pesan server-ke-client

Autentikasi: Dapat menggunakan mekanisme autentikasi HTTP standar

Kapan menggunakan SSE

Transport SSE cocok untuk:

Akses remote di seluruh jaringan

Skenario multi-client

Layanan publik

Alat terpusat yang perlu diakses banyak pengguna

Integrasi dengan layanan web

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 kamu.

STDIO: Deployment lokal

Server STDIO 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: Mengandalkan izin filesystem mesin lokal

Integrasi: Integrasi mudah dengan sumber daya sistem lokal (file, proses)

Eksekusi: Dimulai dan dihentikan bersama Bob (siklus hidup proses anak)

Dependensi: Setiap dependensi harus diinstal di mesin pengguna

Contoh kasus penggunaan:

Alat pencarian file lokal menggunakan STDIO akan:

Berjalan di mesin kamu

Memiliki akses langsung ke filesystem lokal

Dimulai saat diperlukan oleh Bob

Tidak memerlukan konfigurasi jaringan

Perlu diinstal bersama Bob atau melalui package manager

Remote: Deployment yang di-hosting

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

Instalasi: Diinstal sekali di server, diakses oleh banyak pengguna

Distribusi: Deployment tunggal melayani banyak client

Pembaruan: Pembaruan terpusat langsung memengaruhi 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 berkelanjutan)

Dependensi: Dikelola di server, bukan di mesin pengguna

Contoh kasus penggunaan:

Alat kueri database menggunakan transport remote akan:

Berjalan di server pusat

Terhubung ke database dengan kredensial sisi server

Tersedia terus-menerus untuk banyak pengguna

Memerlukan konfigurasi keamanan jaringan yang tepat

Di-deploy menggunakan teknologi container atau cloud

Pendekatan hybrid

Beberapa skenario mendapat manfaat dari pendekatan hybrid:

STDIO dengan akses jaringan: Server STDIO lokal yang bertindak sebagai proxy ke layanan remote

Remote dengan perintah lokal: Server remote yang dapat memicu operasi di mesin client melalui callback

Pola gateway: Server STDIO untuk operasi lokal yang terhubung ke server remote untuk fungsi khusus

Perbandingan transport

Pertimbangan	STDIO	Streamable HTTP / SSE
Lokasi	Hanya mesin lokal	Lokal atau remote
Client	Single client	Multiple client
Performa	Latensi lebih rendah	Latensi lebih tinggi (overhead jaringan)
Kompleksitas setup	Lebih sederhana	Lebih kompleks (memerlukan HTTP server)
Keamanan	Secara inheren aman	Memerlukan langkah keamanan eksplisit
Akses jaringan	Tidak diperlukan	Diperlukan
Skalabilitas	Terbatas pada mesin lokal	Dapat didistribusikan di seluruh jaringan
Deployment	Instalasi per pengguna	Instalasi terpusat
Pembaruan	Pembaruan terdistribusi	Pembaruan terpusat
Penggunaan sumber daya	Menggunakan sumber daya client	Menggunakan sumber daya server
Dependensi	Dependensi sisi client	Dependensi sisi server

Konfigurasi transport di Bob Shell

Untuk informasi terperinci tentang mengonfigurasi transport di Bob Shell, termasuk contoh konfigurasi, lihat MCP di Bob Shell.

Transport MCP server