Model Context Protocol (MCP) adalah salah satu topik paling hype di dunia pengembangan AI saat ini. Diperkenalkan oleh Anthropic pada akhir 2024, MCP digadang-gadang sebagai “USB-C untuk AI”: sebuah standar terbuka yang memungkinkan model bahasa (LLM) seperti Claude, GPT, atau model lokal terhubung ke sumber data dan alat (tools) eksternal secara seragam. Sebelum MCP, setiap integrasi AI harus dibuat manual satu per satu (integrasi M × N). Dengan MCP, kamu cukup membangun satu server, dan semua klien yang mendukung MCP bisa langsung memakainya.

Di tutorial ini, kita akan membangun server MCP sendiri menggunakan Python dengan library resmi mcp dan FastMCP. Kamu akan membuat tools yang bisa dipanggil LLM, mengekspos resources dan prompts, mengujinya lewat MCP Inspector, lalu menghubungkannya ke aplikasi klien. Semua kode di bawah bisa langsung dijalankan.

Apa Itu MCP dan Mengapa Penting?

Secara sederhana, MCP adalah protokol client–server yang distandarkan. Sebuah MCP server mengekspos kemampuan (tools, resources, prompts) melalui transport standar (biasanya stdio atau HTTP/SSE). Sebuah MCP client — misalnya Claude Desktop, IDE, atau aplikasi buatanmu — terhubung ke server itu dan memanggil kemampuan tersebut atas nama LLM.

Manfaat utamanya: sekali bangun, dipakai di mana-mana. Kamu tidak perlu menulis ulang koneksi database, akses file, atau panggilan API untuk setiap chatbot. Cukup tulis satu server MCP, lalu Claude Desktop, Cursor, dan aplikasi lain yang mendukung MCP bisa langsung menggunakannya.

Istilah kunci MCP: Tools = fungsi yang bisa dipanggil LLM (misal hitung kata, ambil data cuaca). Resources = data yang bisa dibaca LLM (misal isi file, konfigurasi). Prompts = template prompt siap pakai yang disediakan server.

Prasyarat

Sebelum mulai, pastikan kamu sudah punya:

  • Python 3.10 atau lebih baru (library resmi MCP membutuhkannya). Cek dengan python3 --version.
  • Kemampuan dasar Python (fungsi, decorator, dan asyncio sekilas saja).
  • Opsional: Node.js untuk menjalankan MCP Inspector, dan aplikasi Claude Desktop jika ingin menguji integrasi nyata.
Langkah 1: Menyiapkan Lingkungan Proyek

Pertama, buat folder proyek dan virtual environment agar dependensi tidak mengotori sistem. Kita juga memasang mcp beserta ekstra [cli] supaya perintah mcp dev (untuk membuka Inspector) tersedia.

bash
# Buat folder proyek dan masuk ke dalamnya
mkdir mcp-tutorial && cd mcp-tutorial

# Buat dan aktifkan virtual environment
python3 -m venv venv
source venv/bin/activate

# Pasang SDK resmi MCP beserta CLI-nya
pip install "mcp[cli]"

Setelah instalasi selesai, cek versinya untuk memastikan semua berjalan baik:

bash
python -c "import mcp; print(mcp.__version__ if hasattr(mcp, '__version__') else 'OK')"
mcp --help

Kamu pengguna uv? Kamu bisa membuat environment lebih cepat dengan uv venv lalu uv pip install "mcp[cli]". Hasil akhirnya sama, hanya lebih singkat dan cepat.

Langkah 2: Membuat Server MCP Pertama

Buat file bernama server.py. Di sini kita pakai FastMCP, antarmuka tingkat tinggi dari SDK resmi yang membuat definisi tools jadi sangat ringkas berkat decorator. Kita akan membuat server utilitas teks sederhana berisi tiga tools, satu resource, dan satu prompt.

python
# server.py
from mcp.server.fastmcp import FastMCP

# Inisialisasi server MCP dengan nama unik
mcp = FastMCP("TextUtils")


# ---------- TOOLS: fungsi yang bisa dipanggil LLM ----------
@mcp.tool()
def count_words(text: str) -> int:
    """Menghitung jumlah kata dalam sebuah teks."""
    return len(text.split())


@mcp.tool()
def reverse_text(text: str) -> str:
    """Membalik urutan karakter sebuah teks."""
    return text[::-1]


@mcp.tool()
def to_uppercase(text: str) -> str:
    """Mengubah seluruh teks menjadi huruf kapital."""
    return text.upper()


# ---------- RESOURCES: data yang bisa dibaca LLM ----------
@mcp.resource("config://app")
def get_config() -> str:
    """Mengembalikan konfigurasi aplikasi dalam format JSON."""
    return '{"name": "TextUtils", "version": "1.0.0"}'


# ---------- PROMPTS: template prompt siap pakai ----------
@mcp.prompt()
def rewrite_style(text: str) -> str:
    """Template prompt untuk menulis ulang teks."""
    return f"Tulis ulang teks berikut dengan gaya yang profesional dan jelas:\n\n{text}"


if __name__ == "__main__":
    mcp.run()

Beberapa hal penting dari kode di atas:

  • @mcp.tool() mendaftarkan fungsi sebagai tool. Nama, type hint, dan docstring fungsi otomatis menjadi metadata yang dikirim ke LLM, sehingga LLM tahu kapan dan bagaimana memanggilnya.
  • @mcp.resource() mendaftarkan data dengan pola URI (config://app). LLM bisa “membaca” resource ini tanpa harus memanggil tool.
  • @mcp.prompt() mendaftarkan template prompt yang bisa dipilih pengguna di klien.
  • mcp.run() menjalankan server lewat transport stdio (standar input/output) secara default — ini transport yang paling umum untuk server lokal.

Jangan jalankan server.py secara langsung dengan python server.py untuk “melihat hasilnya” — server stdio menunggu pesan dari klien lewat stdin, jadi terminal akan tampak diam. Itu normal. Cara yang benar adalah mengujinya lewat MCP Inspector atau klien (langkah berikutnya).

Langkah 3: Menguji Server dengan MCP Inspector

MCP Inspector adalah alat resmi berbasis web untuk menguji server MCP secara interaktif. Berkat ekstra [cli] yang tadi kita pasang, kamu cukup menjalankan perintah berikut dari folder proyek:

bash
mcp dev server.py

Perintah ini akan membuka halaman Inspector di browser (biasanya di http://localhost:5173). Di sana kamu akan melihat tab Tools, Resources, dan Prompts. Klik tab Tools, pilih count_words, isi parameter text dengan kalimat apa pun, lalu klik Run. Kamu akan melihat hasil berupa jumlah kata yang dikembalikan server.

Jika muncul error saat membuka Inspector, biasanya karena port sudah terpakai atau Node.js belum terpasang. Pastikan Node.js tersedia dengan node --version sebelum menjalankan mcp dev.

Langkah 4: Memanggil Server dari Kode Python (Client)

Selain Inspector, kamu juga bisa menulis klien sendiri. Ini berguna jika kamu ingin menyematkan kemampuan MCP ke dalam aplikasi Python atau agent buatanmu. Buat file client.py berikut:

python
# client.py
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client


async def main():
    # Parameter untuk menjalankan server via stdio
    params = StdioServerParameters(
        command="python",
        args=["server.py"],
    )

    async with stdio_client(params) as (read, write):
        async with ClientSession(read, write) as session:
            # Wajib dipanggil untuk memulai sesi
            await session.initialize()

            # Ambil daftar tool yang tersedia
            tools = await session.list_tools()
            print("Tools tersedia:", [t.name for t in tools.tools])

            # Panggil tool count_words
            result = await session.call_tool(
                "count_words", {"text": "Halo dunia selamat pagi"}
            )
            print("Hasil count_words:", result.content[0].text)

            # Baca resource config://app
            resources = await session.read_resource("config://app")
            print("Isi resource:", resources.contents[0].text)


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

Jalankan klien dengan python client.py. Output yang diharapkan kira-kira seperti ini:

bash
Tools tersedia: ['count_words', 'reverse_text', 'to_uppercase']
Hasil count_words: 4
Isi resource: {"name": "TextUtils", "version": "1.0.0"}

Kesalahan umum: jika kamu melihat error ModuleNotFoundError: mcp, pastikan virtual environment masih aktif (source venv/bin/activate) dan mcp sudah terpasang di environment yang sama tempat kamu menjalankan klien.

Langkah 5: Menghubungkan ke Claude Desktop

Inilah bagian yang membuat MCP terasa ajaib: menghubungkan server ke aplikasi nyata. Claude Desktop membaca konfigurasi MCP dari file claude_desktop_config.json. Isi file tersebut (di macOS: ~/Library/Application Support/Claude/claude_desktop_config.json; di Windows: %APPDATA%\Claude\claude_desktop_config.json) dengan konfigurasi berikut, sesuaikan path absolut ke server.py-mu:

json
{
  "mcpServers": {
    "text-utils": {
      "command": "python",
      "args": ["/path/absolut/ke/server.py"],
      "env": {}
    }
  }
}

Simpan file, lalu restart Claude Desktop. Setelah itu, klik ikon tools/plug di kotak chat — kamu akan melihat server text-utils dengan tools count_words, reverse_text, dan to_uppercase yang terdaftar. Coba tanya: “Gunakan tool count_words untuk menghitung kata dari kalimat berikut: belajar MCP itu menyenangkan” — Claude akan memanggil tool-mu dan menampilkan hasilnya.

Di server produksi, jangan pakai command: python yang mengandalkan PATH sistem. Sebaiknya arahkan command ke path Python absolut di dalam virtual environment, misalnya /home/user/mcp-tutorial/venv/bin/python, agar dependensi selalu ditemukan.

Cara Kerja MCP di Balik Layar (Ringkas)

Ketika klien terhubung, terjadi pertukaran pesan JSON-RPC lewat transport stdio. Alurnya kira-kira: klien mengirim initialize, server membalas dengan daftar kapabilitas; klien memanggil tools/list untuk mengetahui tools apa saja yang tersedia; saat LLM memutuskan memakai tool, klien mengirim tools/call dengan argumen, dan server membalas hasilnya. Karena pesannya berstandar JSON-RPC, semua klien yang mematuhi spesifikasi MCP bisa saling beroperasi.

Kesimpulan

Selamat! Kamu sudah membangun server MCP pertama dengan Python, mengujinya lewat MCP Inspector, memanggilnya dari kode Python, dan menghubungkannya ke Claude Desktop. Dari fondasi ini, kamu bisa bereksperimen lebih jauh: tambahkan tool yang membaca database, memanggil API eksternal, mengakses file lokal, atau menjalankan perintah sistem — semuanya cukup didaftarkan sebagai fungsi ber-decorator @mcp.tool().

MCP masih berkembang pesat dan semakin banyak aplikasi yang mendukungnya (Claude, Cursor, dan berbagai agent framework). Menguasainya sekarang berarti kamu selangkah lebih depan dalam membangun aplikasi AI yang benar-benar terhubung dengan dunia nyata. Selamat ngoding!