Tutorial MCP Server Python: Hubungkan Database ke Claude Code

Model Context Protocol (MCP) menjadi standar komunikasi yang semakin populer antara AI agent dan external tools. Dengan MCP, Claude Code, Cursor, dan IDE lainnya bisa mengakses database, API internal, atau bahkan file system secara langsung. Artikel ini akan membimbing kamu membangun MCP server sederhana dengan Python yang menghubungkan Claude Code ke database SQLite.

Apa itu Model Context Protocol (MCP)

MCP adalah protokol open source yang dikembangkan Anthropic untuk memungkinkan LLM berinteraksi dengan tools eksternal secara terstruktur. Konsepnya mirip dengan LSP (Language Server Protocol), tapi fokus pada konteks dan tools, bukan syntax highlighting. MCP server mengekspose tools, resources, dan prompts yang bisa dipanggil oleh AI agent.

Menurut dokumentasi resmi Anthropic, MCP menggunakan transport layer berbasis JSON-RPC 2.0 yang bisa berjalan via stdio atau HTTP. Ini membuatnya fleksibel untuk integrasi lokal maupun remote. Kamu bisa membaca spesifikasi lengkap di modelcontextprotocol.io.

Prasyarat dan Setup Environment

Sebelum memulai, pastikan environment kamu sudah siap:

Python 3.10 atau lebih baru
pip atau uv untuk package management
Claude Code atau Claude Desktop yang sudah terinstall
Database SQLite sederhana untuk eksperimen

Buat virtual environment baru dan install SDK MCP official dari Anthropic:

python3 -m venv venv
source venv/bin/activate
pip install mcp sqlite3

Untuk panduan instalasi Claude Code, kunjungi docs.anthropic.com/en/docs/claude-code/setup.

Langkah 1: Membuat Database SQLite

Buat file database sederhana dengan tabel users dan orders. Kita akan gunakan ini sebagai data source yang diakses MCP server.

import sqlite3

conn = sqlite3.connect('shop.db')
cursor = conn.cursor()

cursor.execute('''
CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY,
    name TEXT NOT NULL,
    email TEXT UNIQUE
)
''')

cursor.execute('''
CREATE TABLE IF NOT EXISTS orders (
    id INTEGER PRIMARY KEY,
    user_id INTEGER,
    total REAL,
    status TEXT
)
''')

# Seed data
cursor.execute("INSERT INTO users (name, email) VALUES ('Budi', 'budi@example.com')")
cursor.execute("INSERT INTO orders (user_id, total, status) VALUES (1, 250000, 'completed')")
conn.commit()
conn.close()

Jalankan script di atas untuk menghasilkan file shop.db di working directory.

Langkah 2: Membangun MCP Server

Buat file server.py dan implementasikan MCP server menggunakan SDK Python. Server ini akan mengekspose dua tools: get_user dan get_orders.

from mcp.server import Server
from mcp.types import TextContent
import sqlite3

app = Server("sqlite-shop-server")

def query_db(query, params=()):
    conn = sqlite3.connect('shop.db')
    conn.row_factory = sqlite3.Row
    cursor = conn.cursor()
    cursor.execute(query, params)
    rows = cursor.fetchall()
    conn.close()
    return [dict(row) for row in rows]

@app.call_tool()
def call_tool(name: str, arguments: dict):
    if name == "get_user":
        user_id = arguments.get("user_id")
        rows = query_db("SELECT * FROM users WHERE id = ?", (user_id,))
        return [TextContent(type="text", text=str(rows))]
    
    if name == "get_orders":
        status = arguments.get("status")
        if status:
            rows = query_db("SELECT * FROM orders WHERE status = ?", (status,))
        else:
            rows = query_db("SELECT * FROM orders")
        return [TextContent(type="text", text=str(rows))]
    
    raise ValueError(f"Unknown tool: {name}")

@app.list_tools()
def list_tools():
    return [
        {
            "name": "get_user",
            "description": "Get user by ID",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "user_id": {"type": "integer"}
                },
                "required": ["user_id"]
            }
        },
        {
            "name": "get_orders",
            "description": "Get orders, optionally filter by status",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "status": {"type": "string"}
                }
            }
        }
    ]

if __name__ == "__main__":
    from mcp.server.stdio import stdio_server
    import asyncio
    
    async def main():
        async with stdio_server() as streams:
            await app.run(streams[0], streams[1], app.create_initialization_options())
    
    asyncio.run(main())

Pola di atas mengikuti arsitektur Server class dari anthropic-mcp SDK. Setiap tool didefinisikan dengan JSON Schema untuk validasi argument otomatis.

Langkah 3: Konfigurasi Claude Code

Agar Claude Code mengenali MCP server kita, tambahkan konfigurasi di file claude.json. Lokasi file bervariasi tergantung OS:

macOS: ~/Library/Application Support/Claude/claude.json
Linux: ~/.config/claude/claude.json

{
  "mcpServers": {
    "sqlite-shop": {
      "command": "python3",
      "args": ["/path/to/server.py"]
    }
  }
}

Pastikan path ke server.py menggunakan absolute path. Restart Claude Code setelah mengubah konfigurasi. Kamu bisa memverifikasi konfigurasi dengan perintah /mcp di dalam Claude Code.

Langkah 4: Testing dan Debugging

Setelah konfigurasi aktif, buka Claude Code dan coba prompt berikut:

Berapa total order yang statusnya completed?

Claude akan secara otomatis memanggil tool get_orders dengan parameter status=completed, lalu menjumlahkan hasilnya. Jika server tidak merespons, periksa log dengan menjalankan server secara manual:

python3 server.py

Pastikan tidak ada error import atau permission issue. Gunakan uv run atau pip install -e . jika kamu mengalami masalah dependency.

Langkah 5: Ekspansi ke Production

Untuk production, pertimbangkan beberapa improvement:

Connection pooling: Gunakan sqlalchemy atau psycopg2.pool untuk menghindari overhead connect/disconnect.
Authentication: Tambahkan API key atau OAuth jika MCP server diexpose via HTTP transport.
Logging: Integrasikan dengan structlog atau loguru untuk observability.
Error handling: Bungkus query dengan try/except dan return pesan error yang readable untuk LLM.

Repository contoh lengkap bisa kamu temukan di github.com/modelcontextprotocol/python-sdk.

Kesimpulan

Membangun MCP server dengan Python tidak serumit yang dibayangkan. Dengan SDK official dari Anthropic, kamu bisa menghubungkan database internal, API legacy, atau bahkan hardware IoT ke Claude Code dalam waktu kurang dari satu jam. Protokol ini membuka pola baru dalam integrasi AI: agent tidak lagi sekadar chatbot, tapi menjadi operator sistem yang bisa membaca dan menulis data secara aktif.

Untuk eksplorasi lebih lanjut, coba tambahkan tool untuk INSERT/UPDATE operation, atau hubungkan ke PostgreSQL dan Redis. Semakin banyak tools yang kamu ekspose, semakin powerful AI agent bekerja dalam codebase kamu.

Tutorial Membangun MCP Server dengan Python: Hubungkan Database ke Claude Code