Belajar Generative AI - MCP (Model Context Protocol)

#Pendahuluan

Setelah di episode 10 kalian membangun agent dengan state machine dan orchestration, muncul masalah yang sangat nyata di produksi: setiap agent butuh tools yang berbeda, dan setiap tools butuh integrasi kustom. Menghubungkan agent ke GitHub, ke database, ke Slack, ke API internal — semuanya dengan kode ad-hoc yang berbeda-beda. MCP (Model Context Protocol) diciptakan untuk memecahkan masalah ini: satu protokol standar agar tools dan data bisa dipakai oleh model apa pun.

Mengapa ini penting di 2026? Karena MCP adalah kandidat kuat untuk menjadi "USB-C"-nya AI — antarmuka universal. Anthropic membukanya pada 2025, dan dalam waktu singkat seluruh ekosistem mengadopsinya: framework agent, IDE, browser, hingga layanan cloud. Memahami MCP berarti kalian bisa membuat tools yang sekali dibangun, dipakai banyak model.

#Arsitektur MCP

MCP menggunakan arsitektur host–client–server:

Tiga konsep utama yang di-expose server:

Transport standarnya adalah JSON-RPC 2.0, bisa lewat stdio (proses lokal) atau Streamable HTTP / SSE (jaringan). Arsitektur ini memisahkan tegas: host tidak perlu tahu detail tool, server yang mendaftarkan dirinya.

#Discovery: Host Menemukan Kemampuan Server

Salah satu keunggulan MCP adalah discovery otomatis. Saat terhubung, host menjalankan handshake:

1. Client mengirim initialize dengan versi protokol & kapabilitas.
2. Server merespons dengan daftar kapabilitas dan informasi server.
3. Client meminta daftar tools (via tools/list), resources, dan prompts.
4. Model lalu bisa memilih tool yang relevan — persis seperti function calling di episode 9, tapi terstandardisasi.

{
  "tools": [
    {
      "name": "get_stock_price",
      "description": "Ambil harga saham terakhir",
      "inputSchema": {
        "type": "object",
        "properties": { "symbol": { "type": "string" } },
        "required": ["symbol"]
      }
    }
  ]
}

Model melihat daftar ini dan memutuskan kapan memanggil get_stock_price — mekanismenya identik dengan tool schema di episode 9, hanya kini lewat protokol bersama.

#Membangun MCP Server: Tool, Resource, Prompt

Mari bangun MCP server sederhana dengan FastMCP — SDK Python resmi yang membuatnya sangat ringkas:

from fastmcp import FastMCP
 
mcp = FastMCP("produk-server")
 
@mcp.tool()
def cek_stok(sku: str) -> str:
    """Cek ketersediaan stok produk di gudang."""
    # dalam praktik: query database inventori
    return f"SKU {sku}: tersedia 12 unit, harga 250000"
 
@mcp.tool()
def hitung_diskon(harga: int, persen: int) -> int:
    """Hitung harga setelah diskon."""
    return harga * (100 - persen) // 100
 
@mcp.resource("produk://katalog")
def katalog() -> str:
    """Daftar produk aktif sebagai referensi."""
    return "Produk: A-100, B-200, C-300 (semua aktif)"
 
if __name__ == "__main__":
    mcp.run()   # default transport stdio

Dekorator @mcp.tool() otomatis menghasilkan schema dari type hint Python — deskripsi dari docstring, tipe dari anotasi. Satu server ini bisa di-expose dengan berbagai transport tanpa mengubah logika.

#Menjalankan Server & Menguji dengan Client

Jalankan server di atas transport yang berbeda:

python3 mcp_server.py               # stdio (dipakai host lokal/agent)
python3 mcp_server.py --transport sse --port 8000   # jaringan

Untuk menguji dari sisi client Python:

import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
 
async def main():
    params = StdioServerParameters(command="python3", args=["mcp_server.py"])
    async with stdio_client(params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            tools = await session.list_tools()
            print([t.name for t in tools.tools])     # ['cek_stok', 'hitung_diskon']
            res = await session.call_tool("hitung_diskon",
                                          arguments={"harga": 250000, "persen": 10})
            print(res.content[0].text)               # 225000
 
asyncio.run(main())

Perhatikan: sebagai engineer, kalian bisa menguji MCP server tanpa LLM sama sekali — cukup client langsung. Ini membuat MCP server sangat mudah di-test dalam CI (konsep penting di episode 15).

#Integrasi MCP dengan Agent

Sekarang hubungkan server itu ke agent. Dengan LangGraph (episode 10), integrasi MCP berarti mengimpor tools dari server:

from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import create_react_agent
from mcp import StdioServerParameters
 
params = StdioServerParameters(command="python3", args=["mcp_server.py"])
# load_mcp_tools membuka sesi MCP, mengambil tools/list, lalu
# mendaftarkannya sebagai tools LangChain → dipakai di agent loop
tools = load_mcp_tools(params)
 
agent = create_react_agent(model="gpt-4o-mini", tools=tools)
 
result = agent.invoke({"messages": [
    {"role": "user", "content": "Harga A-100 setelah diskon 10%?"}]})
print(result["messages"][-1].content)

Alur lengkapnya: agent menerima pertanyaan → model memilih tool dari daftar MCP → client MCP meneruskan ke server → hasil kembali → loop berlanjut. Host, client, server semuanya terpisah — inilah kekuatan protokol.

#Security & Governance MCP

MCP server punya akses langsung ke sistem (database, shell, API) — sehingga menjadi target serangan. Praktik wajib:

• Authenticate & authorize setiap tool call di server — jangan percaya siapa pun yang terhubung.
• Validate input server-side: schema dari client tidak boleh dipercaya.
• Sandbox untuk tool berbahaya (shell, file): ganti user, batasi filesystem, log semua aksi.
• Audit trail: log setiap pemanggilan tool dengan siapa, kapan, argumen apa (dasar di episode 16 & 18).

#Penutup

Inti yang harus dibawa pulang:

• MCP = protokol standar (host–client–server, JSON-RPC) agar tools/data bisa dipakai model apa pun.
• Tiga konsep: tools (aksi), resources (data), prompts (workflow).
• FastMCP membuat server ringkas: dekorator → schema otomatis.
• Integrasi ke agent (LangGraph) tinggal load_mcp_tools — dan server bisa diuji tanpa LLM.

Di episode 12 selanjutnya kita akan masuk ke Fine-Tuning & PEFT — kapan perlu fine-tune vs prompt/RAG, PEFT (LoRA/QLoRA), dan RLHF/DPO dasar — lalu mempraktikkan fine-tune model open-weight (Llama/Qwen/Gemma) dengan PEFT untuk domain spesifik. Sampai jumpa di episode 12!