Membangun Agen AI dengan Multi-Model: Panduan Arsitektur Praktis

Kebanyakan agen AI menggunakan satu model untuk semua hal. Langkah perencanaan, pemanggilan alat, pembuatan ringkasan, pemulihan kesalahan. Ini cocok untuk demo. Namun dalam produksi, ini boros.

Langkah perencanaan yang memerlukan penalaran mendalam tidak perlu menggunakan model yang sama dengan langkah ekstraksi JSON. Tugas pembuatan kode memiliki kebutuhan berbeda dibandingkan tugas klasifikasi. Menggunakan Claude Opus 4.6 ($25/1M token output) hanya untuk memformat string tanggal seperti menyewa arsitek senior untuk mengecat dinding.

Berikut cara membangun agen yang mengarahkan setiap langkah ke model yang optimal.

Arsitektur Agen Multi-Model

User Request
    │
    ▼
┌─────────────┐
│   Router     │  ← Mengklasifikasikan kompleksitas tugas
│  (fast model)│
└──────┬──────┘
       │
   ┌───┴───┐
   ▼       ▼
┌──────┐ ┌──────┐
│Simple│ │Complex│
│Model │ │Model  │
└──┬───┘ └──┬───┘
   │        │
   ▼        ▼
┌─────────────┐
│  Aggregator  │  ← Menggabungkan hasil
│  (fast model)│
└─────────────┘

Tiga komponen:

Router yang mengklasifikasikan tugas masuk berdasarkan kompleksitas
Pool model yang disesuaikan dengan tipe tugas berbeda
Aggregator yang menggabungkan hasil bila diperlukan

Implementasi dengan OpenAI SDK

Dengan menggunakan satu API key melalui aggregator, Anda dapat mengakses semua model tanpa harus mengelola banyak SDK:

from openai import OpenAI

client = OpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Pool model dengan tingkatan biaya/kapabilitas
MODELS = {
    "router": "gpt-4.1-mini",        # $0.40/1M input - klasifikasi cepat
    "simple": "gpt-4.1-mini",        # $0.40/1M input - ekstraksi, pemformatan
    "reasoning": "claude-sonnet-4-6",# $3.00/1M input - perencanaan, analisis
    "complex": "gpt-4.1",            # $2.00/1M input - pembuatan kode, multi-langkah
    "budget": "deepseek-chat",       # $0.28/1M input - pemrosesan massal
}

def route_task(task: str) -> str:
    """Gunakan model murah untuk mengklasifikasikan kompleksitas tugas."""
    response = client.chat.completions.create(
        model=MODELS["router"],
        messages=[
            {"role": "system", "content": """Klasifikasikan tugas ini ke dalam satu kategori:
- simple: ekstraksi data, pemformatan, terjemahan
- reasoning: analisis, perencanaan, perbandingan
- complex: pembuatan kode, pemecahan masalah multi-langkah
- budget: pemrosesan massal, tugas non-kritis
Balas hanya dengan nama kategori."""},
            {"role": "user", "content": task}
        ],
        max_tokens=10
    )
    category = response.choices[0].message.content.strip().lower()
    return MODELS.get(category, MODELS["simple"])

def execute_task(task: str, context: str = "") -> str:
    """Arahkan tugas ke model yang sesuai dan jalankan."""
    model = route_task(task)
    messages = []
    if context:
        messages.append({"role": "system", "content": context})
    messages.append({"role": "user", "content": task})

    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    return response.choices[0].message.content

Agen Dunia Nyata: Pipeline Review Kode

Berikut agen multi-model praktis yang melakukan review pull request:

def review_pr(diff: str) -> dict:
    """Pipeline review PR multi-model."""

    # Langkah 1: Klasifikasi perubahan (model murah)
    classification = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Klasifikasikan perubahan kode ini: {diff[:2000]}\n"
                       "Kategori: bugfix, feature, refactor, docs, test"
        }],
        max_tokens=20
    ).choices[0].message.content

    # Langkah 2: Pemindaian keamanan (model penalaran)
    security = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[{
            "role": "system",
            "content": "Anda adalah reviewer keamanan. Periksa: "
                       "SQL injection, XSS, bypass otentikasi, rahasia dalam kode, "
                       "deserialisasi tidak aman. Sebutkan nomor baris secara spesifik."
        }, {
            "role": "user",
            "content": f"Review diff ini untuk masalah keamanan:\n{diff}"
        }]
    ).choices[0].message.content

    # Langkah 3: Kualitas kode (model umum)
    quality = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{
            "role": "user",
            "content": f"Review kualitas kode: penamaan, struktur, "
                       f"penanganan error, cakupan pengujian.\n{diff}"
        }]
    ).choices[0].message.content

    # Langkah 4: Ringkasan (model murah)
    summary = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Ringkas review PR ini dalam 3 poin utama:\n"
                       f"Tipe: {classification}\n"
                       f"Keamanan: {security[:500]}\n"
                       f"Kualitas: {quality[:500]}"
        }]
    ).choices[0].message.content

    return {
        "classification": classification,
        "security": security,
        "quality": quality,
        "summary": summary
    }

Rincian biaya untuk review PR tipikal (diff 2K token):

Langkah	Model	Token Input	Biaya
Klasifikasi	GPT-4.1-mini	~2.100	$0.0008
Keamanan	Claude Sonnet 4.6	~2.500	$0.0075
Kualitas	GPT-4.1	~2.500	$0.0050
Ringkasan	GPT-4.1-mini	~1.200	$0.0005
Total			~$0.014

Menggunakan Claude Sonnet 4.6 untuk keempat langkah akan menghabiskan biaya sekitar $0.028. Pendekatan multi-model mengurangi biaya hingga 50% sambil menggunakan model terkuat di bagian yang paling penting (review keamanan).

Integrasi LangChain

from langchain_openai import ChatOpenAI

# Membuat instance model dengan konfigurasi berbeda
fast = ChatOpenAI(
    model="gpt-4.1-mini",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

reasoning = ChatOpenAI(
    model="claude-sonnet-4-6",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Digunakan dalam rantai LangChain
from langchain_core.prompts import ChatPromptTemplate

classify_chain = ChatPromptTemplate.from_template(
    "Klasifikasikan: {input}"
) | fast

analyze_chain = ChatPromptTemplate.from_template(
    "Analisis secara mendalam: {input}"
) | reasoning

Kapan Menggunakan Agen Multi-Model

Routing multi-model menambah kompleksitas. Ini layak digunakan ketika:

Agen Anda menangani berbagai tipe tugas (bukan hanya chat)
Biaya API bulanan melebihi $100 (penghematan menjadi signifikan)
Anda membutuhkan kekuatan model spesifik (Claude untuk kode, Gemini untuk konteks panjang, GPT untuk kecepatan)
Latensi penting untuk beberapa langkah tapi tidak untuk yang lain

Untuk chatbot sederhana atau agen dengan tujuan tunggal, satu model sudah cukup. Overhead routing tidak sebanding jika setiap permintaan membutuhkan kapabilitas yang sama.

Poin Penting

Gunakan model termurah yang mampu menangani setiap langkah dengan baik
Sisihkan model mahal hanya untuk tugas yang benar-benar membutuhkannya
Langkah klasifikasi/routing harus selalu menggunakan model termurah yang tersedia
Ukur biaya aktual per eksekusi agen, bukan hanya harga per token
API aggregator dengan satu kunci sangat memudahkan akses multi-model

Akses semua model melalui satu API: lemondata.cc menyediakan 300+ model dengan satu API key. Bangun agen multi-model tanpa harus mengelola banyak akun penyedia.

Membangun Agen AI dengan Beberapa Model: Panduan Arsitektur Praktis