Model Context Protocol (MCP), dan catatan mengenai implementasi server MCP dalam bahasa Go

Longread tentang spesifikasi dan implementasi MCP dalam GO

Konten Halaman

Di sini kita memiliki deskripsi tentang Model Context Protocol (MCP), catatan singkat tentang cara mengimplementasikan server MCP dalam Go, termasuk struktur pesan dan spesifikasi protokol.

Robot dan MCP

Ringkasan Model Context Protocol (MCP)

Model Context Protocol (MCP) adalah kerangka kerja terbuka dan standar (diperkenalkan oleh Anthropic pada akhir 2024) untuk menghubungkan model bahasa AI ke sumber data eksternal, alat, dan sistem. Tujuannya adalah untuk menyelesaikan masalah “N×M integrasi” dengan menyediakan antarmuka universal untuk hal-hal seperti membaca file, menjalankan fungsi (alat), dan menggunakan prompt kontekstual di berbagai aplikasi. MCP bukan protokol proprietary atau internal; ini adalah standar terbuka dengan spesifikasi resmi dan implementasi referensi open-source. Faktanya, penyedia AI utama (termasuk OpenAI dan Google DeepMind) mengumumkan dukungan untuk MCP setelah diperkenalkan, menunjukkan bahwa ini dimaksudkan sebagai standar yang luas diadopsi, bukan solusi khusus vendor.

Tujuan dan Arsitektur MCP

MCP bertujuan untuk menstandarkan cara aplikasi menyediakan konteks ke LLMs – analogi yang sering digunakan adalah “port USB-C untuk aplikasi AI”. Dengan mendefinisikan protokol umum, MCP memungkinkan asisten AI dan alat berinteraksi secara mulus dengan database, sistem file, API, dan sumber daya lainnya tanpa integrasi khusus satu kali. Ini membantu model bahasa menghasilkan respons yang lebih relevan dan up-to-date dengan memberikan akses aman ke data yang mereka butuhkan.

Arsitektur: MCP mengikuti model klien–server dengan pemisahan peran yang jelas:

  • MCP Host: Aplikasi induk (misalnya, klien obrolan atau IDE) yang mengelola koneksi. Ini berisi satu atau lebih MCP klien (konektor).
  • MCP Klien: Instansi konektor (dalam host) yang membangun sesi 1:1 dengan server MCP. Klien mengelola siklus hidup sesi, mengarahkan pesan, dan menerapkan izin pengguna atau kebijakan keamanan apa pun.
  • MCP Server: Layanan ringan yang mengekspos kemampuan tertentu (akses ke data atau fungsi tertentu) melalui protokol MCP. Setiap server mungkin mengemas sumber daya (file, DB, API, dll.) atau alat. Banyak server dapat berjalan secara paralel, masing-masing menyediakan integrasi yang berbeda.
  • Sumber Daya/layanan: Sumber daya aktual yang dihubungkan oleh server – ini dapat mencakup file lokal dan database atau layanan jarak jauh (API web, aplikasi SaaS, dll.). Server MCP bertindak sebagai adapter ke sumber daya ini, memastikan LLM hanya mengakses data melalui protokol standar.

Desain ini terinspirasi oleh Language Server Protocol (LSP) dari dunia IDE. Seperti LSP memungkinkan editor apa pun mendukung bahasa pemrograman apa pun melalui protokol umum, MCP memungkinkan aplikasi AI apa pun terhubung ke integrasi data/alat apa pun yang berbicara MCP. Desain ini memungkinkan pengembang alat AI menulis server MCP sekali dan membuatnya bekerja dengan banyak klien AI, dan pengembang aplikasi AI dapat menambahkan integrasi baru hanya dengan memasang server MCP, menghindari kode integrasi khusus.

Protokol dan Struktur Pesan

Komunikasi: Komunikasi MCP dibangun pada sesi yang bertahan lama dan berstatus menggunakan pesan JSON-RPC 2.0. Semua permintaan dan respons sesuai dengan format JSON-RPC (dengan bidang "jsonrpc": "2.0", nama metode, parameter, dan ID yang berkorelasi). Baik pihak – klien atau server – dapat mengirim permintaan atau notifikasi, memungkinkan interaksi dua arah. Sesi MCP biasanya dimulai dengan jabat tangan:

  • Klien memulai dengan permintaan initialize, menyarankan versi protokol dan mengiklankan kemampuan (fitur yang didukung). Misalnya, klien mungkin menunjukkan bahwa dapat menangani permintaan “sampling” yang diinisiasi oleh server atau menyediakan akar tertentu untuk akses file. Server merespons dengan versi protokol dan kemampuan yang didukungnya sendiri, menyelesaikan fitur mana yang diaktifkan untuk sesi ini (MCP menggunakan sistem negosiasi kemampuan yang mirip dengan fitur opsional dalam LSP). Jika kemampuan kritis atau versi tidak kompatibel, koneksi akan dihentikan secara halus.
  • Setelah kesepakatan, klien mengirimkan notifikasi initialized untuk menandai kesiapan. Setelah ini, operasi normal dapat dilanjutkan. Sesi tetap terbuka untuk pertukaran pesan JSON-RPC yang berkelanjutan hingga salah satu pihak mengeluarkan perintah shutdown.

Transportasi: MCP tidak menentukan satu transportasi – ia berfungsi melalui saluran apa pun yang dapat membawa teks JSON. Secara umum, server MCP dijalankan sebagai proses anak dan berkomunikasi melalui STDIO (pipa stdin/stdout) untuk integrasi lokal. Ini analog dengan cara server bahasa beroperasi dan nyaman untuk alat lokal (host dapat meluncurkan proses server dan mengalirkan pesan). Alternatifnya, server MCP dapat berjalan sebagai layanan independen yang dapat diakses melalui HTTP. Spesifikasi MCP mendefinisikan transportasi streaming HTTP di mana server mengekspos satu titik akhir HTTP untuk panggilan JSON-RPC (klien mengirimkan permintaan POST, dan server dapat merespons atau mengalirkan hasil melalui Server-Sent Events untuk operasi yang berlangsung lama). Dalam kasus apa pun, pesan adalah baris JSON UTF-8, dan protokol mendukung respons streaming dan pesan yang diinisiasi oleh server (pendekatan HTTP+SSE memungkinkan server mengirimkan notifikasi atau hasil parsial secara asinkron). Panduan keamanan merekomendasikan bahwa server lokal mengikat ke localhost dan memvalidasi header Origin untuk mencegah akses jarak jauh yang tidak diinginkan, dan bahwa otentikasi yang tepat (misalnya token atau alur OAuth) digunakan untuk server jarak jauh.

Format Pesan: MCP memanfaatkan tiga jenis pesan JSON-RPC: Permintaan, Respons, dan Notifikasi. Permintaan berisi id, string method, dan (opsional) params (biasanya objek JSON dari argumen). Penerima harus merespons dengan respons yang sesuai (dengan id yang cocok) yang berisi result atau objek error. Notifikasi mirip dengan pesan satu arah dengan method dan params tetapi tanpa id (sehingga tidak mendapatkan respons). MCP menerapkan beberapa aturan di atas JSON-RPC dasar (misalnya, id harus non-null dan tidak digunakan ulang selama sesi) untuk menjaga kejelasan.

Sesi dan Status: Koneksi dianggap sebagai status yang aktif – klien dan server mempertahankan konteks tentang kemampuan masing-masing dan mungkin beberapa status sesi (seperti langganan perubahan, operasi yang berlangsung, dll.). Ada juga prosedur yang ditentukan untuk shutdown yang halus (misalnya, klien dapat mengirimkan permintaan shutdown atau hanya menutup transportasi; server harus menangani pembersihan, dan kedua pihak menerapkan timeout untuk operasi yang tergantung). Penanganan kesalahan mengikuti konvensi JSON-RPC (respons kesalahan memiliki kode dan pesan) dan spesifikasi mendefinisikan kode kesalahan standar untuk kondisi tertentu (misalnya, akses ditolak, alat tidak ditemukan, dll.). MCP juga menyediakan utilitas untuk masalah lintas (misalnya, terdapat notifikasi bawaan untuk pembaruan progres, pembatalan permintaan yang berlangsung lama (CancelledNotification), pesan log/debug, dan perubahan konfigurasi). Ini membantu mengelola interaksi yang panjang atau kompleks (klien dapat membatalkan panggilan alat yang sedang berlangsung, atau server dapat mengirimkan peringatan ke klien, dll.).

Fitur dan Operasi MCP

Setelah diinisialisasi, sesi MCP memungkinkan pertukaran konteks dan perintah secara terstruktur. Fitur inti MCP di sisi server adalah Prompts, Resources, dan Tools (setiap server menyatakan apakah mendukung selama inisialisasi):

  • Prompts: Template prompt atau instruksi yang telah ditentukan sebelumnya yang dapat disediakan oleh server ke klien. Biasanya ini adalah helper yang dipicu oleh pengguna (pengguna secara eksplisit memilih prompt untuk dimasukkan ke dalam percakapan, misalnya melalui perintah slash di UI). MCP menyediakan metode untuk daftar prompt yang tersedia dan mengambil konten prompt. Misalnya, klien dapat memanggil prompts/list untuk mendapatkan daftar template prompt (setiap dengan nama, deskripsi, dan parameter opsional). Untuk mengambil prompt, klien menggunakan prompts/get dengan nama prompt dan nilai argumen apa pun; server kemudian mengembalikan konten prompt (sering kali sebagai set pesan yang akan disisipkan ke konteks LLM). Prompts memungkinkan penggunaan ulang instruksi atau alur kerja kompleks (misalnya, “template tinjauan kode”) yang dapat dipanggil sesuai permintaan. Server menyatakan kemampuan prompts (dengan fitur sub-opsional seperti listChanged untuk memberi tahu klien jika set prompt berubah secara dinamis).

  • Resources: Data terstruktur atau konten yang memberikan konteks ke model. Resources biasanya berupa file, dokumen, entri database – informasi yang mungkin dibaca atau dirujuk oleh asisten AI. MCP menstandarkan cara resources diidentifikasi dan ditransfer: setiap resource memiliki identifikasi URI (misalnya, file:///path/to/file.txt atau skema khusus untuk database). Klien dapat memeriksa apa saja resources yang tersedia melalui resources/list (server mungkin mengekspos pohon direktori, daftar dokumen terbaru, dll.). Respons server mencakup metadata untuk setiap resource (URI, nama, tipe, deskripsi, dll.). Kemudian klien dapat meminta konten dari resource tertentu dengan resources/read, dengan memberikan URI. Server merespons dengan konten resource, yang bisa berupa teks (untuk file), atau data terstruktur (MCP mendukung berbagai jenis konten, seperti teks, JSON, biner, dll., dengan MIME types). Ada juga dukungan untuk resource templates (resource parameterisasi yang diidentifikasi oleh URI template, yang klien dapat mengisi, misalnya, query database di mana pengguna menyediakan parameter). Jika diaktifkan, server dapat mengirimkan notifikasi ketika resource berubah (misalnya, notifications/resources/updated) atau memungkinkan klien untuk berlangganan perubahan pada resource (resources/subscribe). Dalam desain MCP, resources adalah konteks yang dikendalikan aplikasi: aplikasi host (klien) biasanya memutuskan konten resource mana yang akan diberikan ke dalam prompt model (sering kali setelah konfirmasi pengguna atau berdasarkan konteks UI).

  • Tools: Fungsi yang dapat dijalankan atau aksi yang server ekspos untuk model untuk dipanggil. Tools mewakili operasi yang dapat dilakukan AI – misalnya, memanggil API eksternal, menjalankan query database, mengirim email, atau memodifikasi file. Setiap tool memiliki nama dan skema JSON untuk parameter input (dan output opsional), sehingga AI (atau klien) mengetahui argumen apa yang diharapkan. Tools biasanya dikendalikan model: ide adalah model bahasa (agen) memutuskan kapan dan jika menggunakan tool selama percakapan untuk memenuhi permintaan pengguna. Namun, untuk keamanan, pengguna manusia atau aplikasi host mungkin memediasi penggunaan tool (misalnya, memerlukan klik konfirmasi). Menggunakan tools dalam MCP melibatkan dua operasi utama: daftar dan panggil. Klien dapat memanggil tools/list untuk mendapatkan tools yang tersedia dan skemanya. Misalnya, server mungkin menampilkan tool get_weather dengan deskripsi dan skema input yang memerlukan string “lokasi”. Kemudian, ketika model memutuskan untuk menggunakan tool (atau pengguna memanggilnya), klien mengirimkan permintaan tools/call dengan nama tool dan objek JSON dari argumen. Server menjalankan fungsi dan mengembalikan hasilnya, biasanya sebagai bidang result.content yang dapat berisi teks atau data terstruktur (MCP mendukung mengembalikan beberapa bagian konten, misalnya teks plus gambar, dll., meskipun teks umumnya). Contoh sederhana: memanggil tool get_weather mungkin mengembalikan beban teks seperti “Cuaca saat ini di New York: 72°F, sebagian berawan” sebagai konten untuk asisten menampilkan. Tools juga dapat menunjukkan kesalahan (respons memiliki bendera isError atau objek kesalahan jika sesuatu salah). Seperti prompts dan resources, kemampuan tools dapat memiliki bendera opsional listChanged untuk memberi tahu ketika tools yang tersedia berubah selama runtime (misalnya, plugin dinamis yang dimuat/unloaded).

Selain fitur server yang ditawarkan di atas, MCP juga mendefinisikan fitur yang ditawarkan klien (kemampuan yang server dapat memanfaatkan jika klien mendukungnya). Ini termasuk Sampling, Roots, dan Elicitation:

  • Sampling memungkinkan server meminta klien (dan LLM-nya) untuk melakukan inferensi model dalam sesi. Misalnya, server dapat memulai panggilan LLM (mungkin untuk melanjutkan rantai pemikiran atau menyimpulkan sesuatu) dengan mengirimkan permintaan seperti sampling/request – klien kemudian akan mempromosikan model dan mengembalikan hasilnya. Ini memungkinkan perilaku agen di mana server dapat mengarahkan AI untuk membantu dalam tugas sub-nya sendiri. (Semua tindakan seperti ini subjek persetujuan pengguna dan kebijakan – misalnya, pengguna mungkin harus menyetujui untuk memungkinkan server memicu model untuk pertanyaan tambahan.)

  • Roots memungkinkan server untuk menanyakan atau beroperasi dalam akar file sistem atau URI tertentu yang diperbolehkan. Klien dapat menyediakan daftar “akar” direktori/URI yang diperbolehkan server akses melalui roots/list. Ini adalah fitur keamanan yang memastikan server mengetahui batasannya (misalnya, folder mana yang dapat dibaca).

  • Elicitation memungkinkan server meminta klien untuk mendapatkan informasi tambahan dari pengguna jika diperlukan. Misalnya, jika alat membutuhkan informasi yang hilang yang tidak disediakan, server dapat mengirimkan permintaan elicitasi, yang akan diterjemahkan oleh klien (UI) menjadi prompt pengguna (“Integrasi X membutuhkan API key Anda, silakan masukkan”). Dengan demikian server dapat mengumpulkan input secara interaktif melalui klien.

Fitur-fitur ini semua bersifat opsional dan dinegosiasikan sebelumnya. Aspek desain kunci dari MCP adalah bahwa negosiasi kemampuan terjadi selama inisialisasi – klien dan server mengiklankan fitur mana yang mereka dukung, sehingga kedua pihak mengetahui operasi apa yang tersedia dalam sesi. Misalnya, jika server tidak menyatakan kemampuan tools, klien tidak akan mencoba operasi tools/list atau tools/call dengan server tersebut. Aspek ekstensibilitas ini berarti MCP dapat berkembang dengan fitur baru seiring waktu sambil mempertahankan kompatibilitas mundur (metode yang tidak didukung sederhana tidak akan digunakan jika tidak dinegosiasikan).

Implementasi, SDK, dan Membangun Server MCP (terutama dalam Go)

Spesifikasi Resmi & Dokumentasi: Spesifikasi resmi MCP tersedia secara terbuka, termasuk skema formal semua jenis pesan. Ini dikelola di situs web Model Context Protocol dan GitHub. Spesifikasi didefinisikan dalam file skema TypeScript (dengan skema JSON yang sesuai) yang secara tepat mendokumentasikan semua permintaan, respons, dan struktur. Situs dokumentasi (modelcontextprotocol.io) menyediakan panduan, FAQ, dan penjelasan rinci tentang setiap fitur dan jenis pesan, serta alat “MCP Inspector” untuk debugging interaktif. Meskipun MCP belum (masih) menjadi standar IETF atau ISO, ini dikembangkan sebagai standar terbuka dengan masukan komunitas dan menggunakan terminologi RFC 2119 yang familiar untuk persyaratan. Ini adalah protokol yang berkembang (versi diberi tanda tanggal; misalnya, 2025-06-18 adalah revisi terbaru), dengan kebijakan penomoran versi untuk mengelola perubahan.

Implementasi Referensi: Anthropic membuka sumber beberapa konektor server MCP dan SDK ketika memperkenalkan MCP. Ada organisasi GitHub modelcontextprotocol yang menghosting spesifikasi dan beberapa repositori. Secara khusus, repositori “servers” berisi kumpulan implementasi server MCP yang dibangun untuk layanan dan sumber daya umum. Ini berfungsi sebagai integrasi referensi dan sering kali dapat digunakan langsung atau sebagai template untuk server khusus. Misalnya, repo resmi mencakup server untuk Google Drive (akses dan pencarian file di Google Drive), Slack (pesan dan konten saluran kerja), GitHub/Git (konteks repositori kode), PostgreSQL (query database hanya baca dengan informasi skema), Google Maps (API lokasi dan arah), Puppeteer (pencarian dan pengambilan web), dan banyak lagi. Dengan menginstal atau menjalankan server-server ini, aplikasi AI seperti Claude atau Cursor dapat segera mendapatkan integrasi tersebut. Ada juga layanan registry MCP yang didorong komunitas (open-source dalam Go) untuk mengindeks server yang tersedia, dan banyak kontribusi pihak ketiga yang memperluas MCP ke berbagai bidang (dari CRM hingga data blockchain).

SDK dan Perpustakaan: Untuk memfasilitasi pembuatan server/clients MCP Anda sendiri, tersedia SDK resmi dalam beberapa bahasa. Pada 2025, proyek menyediakan SDK untuk TypeScript/Node, Python, Java (dan Kotlin), C# (dikembangkan dengan Microsoft), Ruby (dengan Shopify), Swift, dan lainnya. Perpustakaan ini menangani plumbing protokol – misalnya, mengelola transportasi JSON-RPC, menerapkan skema spesifikasi, dan menyediakan API bantuan untuk mendaftarkan alat atau menyajikan sumber daya. Misalnya, SDK TypeScript dapat digunakan untuk menulis server dengan cepat dalam Node.js, dan SDK Python memungkinkan integrasi MCP dalam aplikasi Python. Pendekatan SDK berarti pengembang tidak perlu membangun pesan JSON-RPC secara manual atau menerapkan mesin status penuh; sebaliknya, mereka memanggil metode tingkat tinggi untuk mengirim permintaan atau menerbitkan kemampuan.

Implementasi Go: Go telah menjadi pilihan populer untuk server MCP karena kekuatannya dalam kinerja dan konkurensi (baik untuk menangani permintaan simultan yang banyak). SDK Go resmi sekarang tersedia, dikembangkan bersama dengan tim Go di Google. (Ini diumumkan sekitar April 2025 dan rilis stabil pertama direncanakan untuk Agustus 2025.) SDK Go menyediakan paket mcp untuk membangun klien/server dan bantuan jsonschema untuk skema alat. Dengan menggunakan SDK Go, pengembang dapat membuat server MCP hanya dengan beberapa panggilan. Misalnya, Anda dapat membuat server baru dengan nama dan versi, lalu menambahkan alat melalui AddTool dengan menyediakan definisi alat (nama, deskripsi, skema input) bersama dengan fungsi penangan Go yang akan dijalankan ketika alat tersebut dipanggil. SDK mengurus ekspos alat dalam protokol (mengiklankannya dalam tools/list dan menangani permintaan tools/call). Dengan cara yang sama, Anda dapat mengekspos sumber daya atau prompt dengan API yang analog. Akhirnya, Anda menjalankan server – misalnya, server.Run(ctx, mcp.NewStdioTransport()) akan memulai pemrosesan pesan JSON-RPC melalui stdio hingga klien terputus. Di sisi klien, SDK Go dapat memulai proses anak dan terhubung melalui mcp.NewCommandTransport(exec.Command("myserver")), kemudian klien dapat memanggil session.CallTool(ctx, params) untuk memanggil alat dan dengan mudah mendapatkan hasilnya dalam kode Go.

Contoh: Dokumentasi SDK Go resmi menunjukkan server “greeter” sederhana. Server mendaftarkan alat "greet" yang mengambil nama dan mengembalikan string salam. Klien kemudian memanggil alat ini berdasarkan nama dan mencetak hasilnya. Ini mengilustrasikan pola dasar: mendefinisikan alat -> klien memanggil alat -> mendapatkan hasil. Di bawah hood, ini sesuai dengan pesan JSON-RPC ("method": "tools/call", params: {"name": "greet", ...} dan respons yang berisi result.content dengan teks) seperti yang didefinisikan oleh spesifikasi MCP.

Sebelum SDK Go resmi dirilis, komunitas menciptakan perpustakaan Go mereka sendiri. Secara khusus, proyek mcp-go oleh Ed Zynda (mark3labs/mcp-go) digunakan secara luas dan memengaruhi desain SDK resmi. Perpustakaan lain, mcp-golang oleh Metoro, menyediakan implementasi dan API Go (posting blog Dev oleh Elton Minetto menggunakan perpustakaan ini sejak awal 2025). Perpustakaan SDK komunitas ini memungkinkan pengembang Go untuk bereksperimen dengan MCP sejak dini – misalnya, satu tutorial menunjukkan cara membangun server MCP yang mencari kode pos Brasil (CEP) dengan mengekspos alat “zipcode” melalui perpustakaan mcp-golang oleh Metoro. Dalam contoh tersebut, server Go mendaftarkan fungsi yang memanggil API eksternal untuk menemukan alamat dari ZIP, dan mengembalikan hasilnya sebagai teks – memungkinkan asisten AI untuk mengambil informasi alamat sesuai permintaan melalui MCP. Panduan lain menunjukkan cara mengemas database in-memory khusus (DiceDB) sebagai server MCP menggunakan SDK mcp-go oleh mark3labs: ia mendefinisikan alat ping untuk memeriksa koneksi DB dan alat lain untuk operasi data. Contoh-contoh ini menyoroti betapa mudahnya membuat integrasi MCP: sebagian besar kode hanya logika bisnis (panggilan API, query DB, dll.), sementara SDK menangani wiring JSON-RPC.

Membangun Server MCP dalam Bahasa Go (Poin Penting Tutorial)

Untuk menguraikan prosesnya, berikut adalah alur umum dengan Go SDK atau perpustakaan serupa:

  1. Mengatur Server: Inisialisasi instance server baru dengan informasi dasar (nama, versi, dan deklarasikan kemampuan yang didukung). Sebagai contoh, dalam Go: server := mcp.NewServer("MyServer", "1.0.0", nil) akan membuat server yang (secara default) mendukung fitur inti protokol. Anda dapat mengaktifkan kemampuan spesifik seperti prompt/sumber daya/alat melalui opsi atau hanya dengan mendaftarkan fitur tersebut (menambahkan alat atau sumber daya berarti kemampuan tersebut aktif).

  2. Mendaftarkan Fitur: Tambahkan fungionalitas yang ingin Anda ekspos:

    • Jika mengunggah Alat, definisikan skema setiap alat dan penangan (handler). Misalnya, menggunakan AddTool dari Go SDK: berikan mcp.Tool{Name: "...", Description: "..."} dan fungsi penangan yang menerima permintaan panggilan dan mengembalikan hasil (yang mungkin mencakup teks atau konten lainnya). SDK akan secara otomatis menghasilkan JSON Schema untuk input dari tipe parameter fungsi penangan Anda (atau Anda dapat menentukannya sendiri).
    • Jika mengunggah Sumber Daya, Anda mungkin menggunakan API untuk mendaftarkan daftar sumber daya atau callback untuk membaca konten. Misalnya, dalam SDK Python, Anda dapat mewarisi kelas ResourceProvider; dalam Go, SDK masih berkembang, tetapi kemungkinan besar Anda akan menyediakan fungsi untuk daftar dan membaca sumber daya. Setiap sumber daya harus memiliki URI yang stabil.
    • Jika mengunggah Prompt, definisikan template prompt (bisa berupa file statis atau string) dan daftarkan dengan nama dan parameter opsional. Server akan mengumumkannya sehingga klien dapat mengambil dan menampilkan kepada pengguna.

  3. Implementasi Transport: Putuskan bagaimana server akan berjalan. Yang paling sederhana untuk penggunaan lokal adalah stdio – misalnya, server.Run(ctx, mcp.NewStdioTransport()) dalam Go akan memulai membaca JSON-RPC dari stdin. Jika server Anda harus terhubung jaringan, Anda mungkin mengimplementasikan penangan HTTP yang menggunakan Go SDK untuk menerima JSON-RPC melalui HTTP (SDK resmi Go mungkin segera menyertakan bantuan untuk transport HTTP/SSE juga).

  4. Pengujian Klien: Anda dapat menguji server dengan klien yang kompatibel dengan MCP. Misalnya, Anthropic’s Claude 2 (Claude untuk Desktop) mendukung memuat server MCP lokal; Anda akan mengonfigurasi Claude untuk meluncurkan atau terhubung ke biner server Anda. Ada juga alat CLI bernama mcp-cli dan GUI MCP Inspector untuk menguji server tanpa klien AI lengkap – alat-alat ini mengirim permintaan MCP ke server Anda dan menampilkan hasilnya, membantu proses debugging.

  5. Keamanan & Hak Akses: Saat membangun server, pertimbangkan otentikasi dan pengaturan hak akses. Untuk server lokal, host mungkin menjalankannya dengan izin OS tertentu atau menyediakan kunci API melalui lingkungan. Untuk server jarak jauh, gunakan header otentikasi atau alur OAuth. MCP mencakup spesifikasi otorisasi untuk transport HTTP (server dapat meminta token dan klien dapat mengirimkannya). Pastikan selalu bahwa server hanya mengakses data yang diizinkan pengguna (misalnya, hormati direktori akar yang diberikan oleh klien, dan jangan bocorkan data ke tempat lain) – panduan MCP menekankan persetujuan pengguna, privasi data, dan keamanan alat sebagai hal mendasar.

Secara ringkas, MCP adalah protokol formal namun fleksibel untuk menghubungkan LLM dengan dunia luar. Ini bukan API internal yang terikat pada satu perusahaan, tetapi standar terbuka dengan adopsi yang berkembang dan ekosistem integrasi yang kaya. Protokol mendefinisikan struktur pesan yang jelas (berbasis JSON-RPC) dan himpunan operasi (metode untuk prompt, alat, sumber daya, dll.) yang dapat diimplementasikan oleh klien/server yang kompatibel. Dokumentasi dan spesifikasi resmi tersedia, serta banyak SDK, perpustakaan, dan contoh server (termasuk dalam Go) membuatnya lebih mudah diimplementasikan. Dengan menggunakan MCP, pengembang dapat membangun aplikasi berbasis AI yang aman memanfaatkan data dan layanan yang ada, tanpa harus merancang logika integrasi ulang untuk setiap model atau dataset baru.

Tautan yang Berguna