Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng

# Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng ## Apa itu Aisuite? Aisuite adalah library Python open-source yang dikembangkan oleh tim Andrew Ng yang memungkinkan developer...

By Ruby Abdullah · · tutorial
AisuiteLLMMulti-ModelAndrew NgPython

Tutorial Lengkap Aisuite: Unified Multi-LLM Interface dari Andrew Ng

Apa itu Aisuite?

Aisuite adalah library Python open-source yang dikembangkan oleh tim Andrew Ng yang memungkinkan developer untuk berinteraksi dengan berbagai Large Language Model (LLM) provider melalui satu interface yang seragam. Dengan aisuite, Anda bisa berpindah antara OpenAI, Anthropic, Google, Mistral, AWS Bedrock, Azure, dan provider lainnya hanya dengan mengubah satu string identifier, tanpa perlu mengubah kode utama Anda.

Bayangkan Anda sedang membangun aplikasi AI dan ingin membandingkan performa antara GPT-4o, Claude Sonnet, dan Gemini untuk use case tertentu. Tanpa aisuite, Anda perlu menulis kode yang berbeda untuk setiap SDK provider. Dengan aisuite, cukup ganti string model identifier dan seluruh kode lainnya tetap sama.

Library ini menggunakan interface yang kompatibel dengan format OpenAI Chat Completions, sehingga jika Anda sudah familiar dengan OpenAI SDK, transisi ke aisuite akan sangat mudah.

Mengapa Menggunakan Aisuite?

Ada beberapa alasan kuat mengapa aisuite layak dipertimbangkan dalam workflow AI Anda:

  • Unified Interface: Satu API untuk semua LLM provider, mengurangi cognitive load dan kode boilerplate
  • Mudah Berpindah Provider: Ganti model hanya dengan mengubah string identifier seperti openai:gpt-4o menjadi anthropic:claude-sonnet-4-6
  • Evaluasi Model yang Cepat: Bandingkan respons dari berbagai model dalam satu script
  • Lightweight: Aisuite bukan wrapper berat, melainkan thin adapter yang mendelegasikan langsung ke SDK masing-masing provider
  • Open Source: Dikembangkan secara terbuka di GitHub dengan kontribusi komunitas
  • Instalasi

    Instalasi Dasar

    Untuk menginstall aisuite, gunakan pip:

    pip install aisuite
    

    Instalasi dengan Provider Spesifik

    Aisuite mendukung instalasi selektif per provider. Ini berguna agar Anda tidak perlu menginstall semua SDK provider jika hanya membutuhkan beberapa saja:

    # Install dengan dukungan OpenAI saja
    

    pip install "aisuite[openai]"

    Install dengan dukungan Anthropic saja

    pip install "aisuite[anthropic]"

    Install dengan beberapa provider sekaligus

    pip install "aisuite[openai,anthropic,google]"

    Install semua provider yang didukung

    pip install "aisuite[all]"

    Provider yang Didukung

    Berikut daftar provider yang didukung oleh aisuite:

    | Provider | Identifier | Package |

    |----------|-----------|---------|

    | OpenAI | openai | openai |

    | Anthropic | anthropic | anthropic |

    | Google (Gemini) | google | google-generativeai |

    | Mistral | mistral | mistralai |

    | AWS Bedrock | aws | boto3 |

    | Azure OpenAI | azure | openai |

    | Groq | groq | groq |

    | Cohere | cohere | cohere |

    | Fireworks AI | fireworks | fireworks-ai |

    | Together AI | together | together |

    | Sambanova | sambanova | openai |

    | Watsonx | watsonx | ibm-watsonx-ai |

    Konfigurasi API Key

    Aisuite membaca API key dari environment variable. Setiap provider memiliki nama environment variable yang standar:

    # Atur environment variable
    

    export OPENAIAPIKEY="sk-..."

    export ANTHROPICAPIKEY="sk-ant-..."

    export GOOGLEAPIKEY="AIza..."

    export MISTRALAPIKEY="..."

    export GROQAPIKEY="gsk..."

    Anda juga bisa menggunakan file .env dengan bantuan python-dotenv:

    from dotenv import loaddotenv
    

    loaddotenv()

    Atau mengatur API key secara langsung dalam kode melalui parameter konfigurasi provider:

    import aisuite as ai
    
    

    client = ai.Client()

    client.configure({"openai": {"apikey": "sk-..."}})

    Basic Usage

    Chat Completion Sederhana

    Berikut contoh dasar penggunaan aisuite untuk membuat chat completion:

    import aisuite as ai
    
    

    client = ai.Client()

    messages = [

    {"role": "system", "content": "Kamu adalah asisten yang helpful dan menjawab dengan ringkas."},

    {"role": "user", "content": "Jelaskan apa itu machine learning dalam 2 kalimat."}

    ]

    Menggunakan OpenAI GPT-4o

    response = client.chat.completions.create(

    model="openai:gpt-4o",

    messages=messages

    )

    print("GPT-4o:", response.choices[0].message.content)

    Perhatikan format model identifier: provider:modelname. Ini adalah konvensi aisuite untuk menentukan provider dan model yang digunakan.

    Membandingkan Beberapa Model

    Salah satu keunggulan utama aisuite adalah kemampuan membandingkan respons dari berbagai model dengan mudah:

    import aisuite as ai
    
    

    client = ai.Client()

    models = [

    "openai:gpt-4o",

    "anthropic:claude-sonnet-4-6",

    "google:gemini-2.0-flash",

    "mistral:mistral-large-latest"

    ]

    messages = [

    {"role": "system", "content": "Kamu adalah data scientist berpengalaman."},

    {"role": "user", "content": "Apa 3 langkah pertama untuk memulai proyek machine learning?"}

    ]

    for model in models:

    response = client.chat.completions.create(

    model=model,

    messages=messages,

    temperature=0.7

    )

    providername = model.split(":")[0]

    print(f"\n{'='50}")

    print(f"Provider: {providername}")

    print(f"Model: {model}")

    print(f"{'='50}")

    print(response.choices[0].message.content)

    Menggunakan Parameter Tambahan

    Aisuite mendukung parameter standar dari OpenAI Chat Completions API:

    import aisuite as ai
    
    

    client = ai.Client()

    messages = [

    {"role": "user", "content": "Tulis sebuah puisi pendek tentang Python programming."}

    ]

    response = client.chat.completions.create(

    model="anthropic:claude-sonnet-4-6",

    messages=messages,

    temperature=0.9,

    maxtokens=500,

    topp=0.95

    )

    print(response.choices[0].message.content)

    Advanced Usage

    Membangun Model Selection Pipeline

    Dalam produksi, Anda mungkin ingin memilih model berdasarkan kriteria tertentu seperti biaya, kecepatan, atau kualitas. Berikut contoh implementasinya:

    import aisuite as ai
    

    import time

    client = ai.Client()

    MODELTIERS = {

    "fast": "groq:llama-3.3-70b-versatile",

    "balanced": "openai:gpt-4o-mini",

    "quality": "anthropic:claude-sonnet-4-6",

    "premium": "openai:gpt-4o"

    }

    def smartcompletion(messages, tier="balanced", kwargs):

    """Pilih model berdasarkan tier yang diinginkan."""

    model = MODELTIERS.get(tier, MODELTIERS["balanced"])

    starttime = time.time()

    response = client.chat.completions.create(

    model=model,

    messages=messages,

    kwargs

    )

    elapsed = time.time() - starttime

    return {

    "content": response.choices[0].message.content,

    "model": model,

    "tier": tier,

    "latencyseconds": round(elapsed, 2)

    }

    Contoh penggunaan

    messages = [{"role": "user", "content": "Apa itu gradient descent?"}]

    Untuk query cepat dan sederhana

    resultfast = smartcompletion(messages, tier="fast")

    print(f"[{resultfast['tier']}] {resultfast['latencyseconds']}s - {resultfast['model']}")

    Untuk query yang membutuhkan kualitas tinggi

    resultquality = smartcompletion(messages, tier="quality")

    print(f"[{resultquality['tier']}] {resultquality['latencyseconds']}s - {resultquality['model']}")

    Fallback dan Retry Pattern

    Implementasi pattern fallback ketika salah satu provider mengalami error:

    import aisuite as ai
    

    import time

    client = ai.Client()

    FALLBACKCHAIN = [

    "anthropic:claude-sonnet-4-6",

    "openai:gpt-4o",

    "google:gemini-2.0-flash",

    "groq:llama-3.3-70b-versatile"

    ]

    def resilientcompletion(messages, maxretries=2, kwargs):

    """Coba beberapa provider secara berurutan jika yang utama gagal."""

    for model in FALLBACKCHAIN:

    for attempt in range(maxretries):

    try:

    response = client.chat.completions.create(

    model=model,

    messages=messages,

    kwargs

    )

    return {

    "content": response.choices[0].message.content,

    "model": model,

    "attempts": attempt + 1

    }

    except Exception as e:

    print(f"Error dengan {model} (attempt {attempt + 1}): {e}")

    time.sleep(1)

    continue

    print(f"Semua retry gagal untuk {model}, mencoba provider berikutnya...")

    raise Exception("Semua provider gagal setelah semua retry attempts.")

    Contoh penggunaan

    messages = [{"role": "user", "content": "Jelaskan konsep attention mechanism."}]

    result = resilientcompletion(messages, temperature=0.3)

    print(f"Berhasil dengan model: {result['model']}")

    print(f"Jumlah attempt: {result['attempts']}")

    print(result['content'])

    Batch Processing dengan Multi-Model

    Memproses banyak prompt sekaligus menggunakan berbagai model:

    import aisuite as ai
    

    from concurrent.futures import ThreadPoolExecutor, ascompleted

    client = ai.Client()

    def processsingle(model, messages, taskid):

    """Proses satu request ke satu model."""

    try:

    response = client.chat.completions.create(

    model=model,

    messages=messages,

    temperature=0.3

    )

    return {

    "taskid": taskid,

    "model": model,

    "content": response.choices[0].message.content,

    "success": True

    }

    except Exception as e:

    return {

    "taskid": taskid,

    "model": model,

    "content": str(e),

    "success": False

    }

    Daftar tugas yang akan diproses

    tasks = [

    {"id": 1, "prompt": "Apa itu neural network?"},

    {"id": 2, "prompt": "Jelaskan random forest."},

    {"id": 3, "prompt": "Apa itu transfer learning?"},

    ]

    models = ["openai:gpt-4o-mini", "anthropic:claude-sonnet-4-6"]

    Jalankan secara parallel

    results = []

    with ThreadPoolExecutor(maxworkers=6) as executor:

    futures = []

    for task in tasks:

    messages = [{"role": "user", "content": task["prompt"]}]

    for model in models:

    future = executor.submit(processsingle, model, messages, task["id"])

    futures.append(future)

    for future in ascompleted(futures):

    result = future.result()

    results.append(result)

    status = "OK" if result["success"] else "FAIL"

    print(f"[{status}] Task {result['taskid']} - {result['model']}")

    Ringkasan

    successcount = sum(1 for r in results if r["success"])

    print(f"\nTotal: {successcount}/{len(results)} berhasil")

    Konfigurasi Provider Khusus

    Beberapa provider memerlukan konfigurasi tambahan. Berikut contoh untuk AWS Bedrock dan Azure:

    import aisuite as ai
    
    

    client = ai.Client()

    Konfigurasi untuk AWS Bedrock

    client.configure({

    "aws": {

    "regionname": "us-east-1",

    "awsaccesskeyid": "AKIA...",

    "awssecretaccesskey": "..."

    }

    })

    Menggunakan model dari AWS Bedrock

    response = client.chat.completions.create(

    model="aws:anthropic.claude-sonnet-4-6-20250514-v1:0",

    messages=[{"role": "user", "content": "Hello dari AWS Bedrock!"}]

    )

    print(response.choices[0].message.content)

    Konfigurasi untuk Azure OpenAI

    client.configure({

    "azure": {

    "apikey": "...",

    "baseurl": "https://your-resource.openai.azure.com/openai/deployments/your-deployment"

    }

    })

    Membangun Simple Evaluation Framework

    Gunakan aisuite untuk membuat framework evaluasi sederhana yang membandingkan kualitas output dari berbagai model:

    import aisuite as ai
    

    import json

    client = ai.Client()

    def evaluatemodels(testcases, models, judgemodel="openai:gpt-4o"):

    """Evaluasi beberapa model menggunakan LLM-as-judge pattern."""

    results = {}

    for model in models:

    results[model] = {"scores": [], "responses": []}

    for test in testcases:

    # Dapatkan respons dari model yang dievaluasi

    response = client.chat.completions.create(

    model=model,

    messages=[{"role": "user", "content": test["prompt"]}],

    temperature=0.3

    )

    answer = response.choices[0].message.content

    # Gunakan judge model untuk menilai

    judgeprompt = f"""Nilai respons berikut berdasarkan kriteria:

  • Akurasi (1-5)
  • Kelengkapan (1-5)
  • Kejelasan (1-5)
  • Pertanyaan: {test['prompt']}

    Respons yang dinilai: {answer}

    Jawaban referensi: {test.get('reference', 'Tidak ada')}

    Berikan skor dalam format JSON:

    {{"accuracy": X, "completeness": X, "clarity": X, "total": X}}

    Hanya berikan JSON, tanpa penjelasan lain."""

    judgeresponse = client.chat.completions.create(

    model=judgemodel,

    messages=[{"role": "user", "content": judgeprompt}],

    temperature=0

    )

    try:

    scores = json.loads(judgeresponse.choices[0].message.content)

    results[model]["scores"].append(scores)

    except json.JSONDecodeError:

    results[model]["scores"].append({"total": 0})

    results[model]["responses"].append(answer)

    # Hitung rata-rata skor

    for model in models:

    scores = results[model]["scores"]

    if scores:

    avgtotal = sum(s.get("total", 0) for s in scores) / len(scores)

    results[model]["avgscore"] = round(avgtotal, 2)

    return results

    Contoh penggunaan

    testcases = [

    {

    "prompt": "Jelaskan perbedaan antara supervised dan unsupervised learning.",

    "reference": "Supervised learning menggunakan data berlabel untuk melatih model, sementara unsupervised learning menemukan pola dari data tanpa label."

    },

    {

    "prompt": "Apa itu overfitting dan bagaimana cara mengatasinya?",

    "reference": "Overfitting terjadi ketika model terlalu fit pada data training. Bisa diatasi dengan regularisasi, cross-validation, dan menambah data."

    }

    ]

    modelstoevaluate = [

    "openai:gpt-4o-mini",

    "anthropic:claude-sonnet-4-6",

    "google:gemini-2.0-flash"

    ]

    results = evaluatemodels(testcases, modelstoevaluate)

    Tampilkan hasil

    print("\n=== Hasil Evaluasi ===")

    for model, data in sorted(results.items(), key=lambda x: x[1].get("avgscore", 0), reverse=True):

    print(f"{model}: Average Score = {data.get('avgscore', 'N/A')}")

    Best Practices

    1. Gunakan Environment Variable untuk API Keys

    Jangan pernah hardcode API key dalam source code. Selalu gunakan environment variable atau secret manager:

    import os
    

    from dotenv import loaddotenv

    loaddotenv()

    Validasi bahwa API key tersedia

    requiredkeys = ["OPENAIAPIKEY", "ANTHROPICAPIKEY"]

    for key in requiredkeys:

    if not os.getenv(key):

    raise ValueError(f"Environment variable {key} tidak ditemukan")

    2. Implementasi Proper Error Handling

    Setiap panggilan ke LLM provider bisa gagal. Pastikan kode Anda menangani error dengan baik:

    import aisuite as ai
    
    

    client = ai.Client()

    def safecompletion(model, messages, kwargs):

    """Wrapper dengan error handling yang proper."""

    try:

    response = client.chat.completions.create(

    model=model,

    messages=messages,

    kwargs

    )

    return response.choices[0].message.content

    except ConnectionError:

    print(f"Koneksi gagal ke {model}")

    return None

    except TimeoutError:

    print(f"Timeout untuk {model}")

    return None

    except Exception as e:

    print(f"Error tidak terduga dengan {model}: {e}")

    return None

    3. Gunakan Caching untuk Efisiensi Biaya

    Hindari memanggil API berulang kali untuk input yang sama:

    import hashlib
    

    import json

    cache = {}

    def cachedcompletion(client, model, messages, kwargs):

    """Completion dengan simple in-memory cache."""

    cachekey = hashlib.md5(

    json.dumps({"model": model, "messages": messages, kwargs}, sortkeys=True).encode()

    ).hexdigest()

    if cachekey in cache:

    return cache[cachekey]

    response = client.chat.completions.create(

    model=model,

    messages=messages,

    kwargs

    )

    result = response.choices[0].message.content

    cache[cachekey] = result

    return result

    4. Logging dan Monitoring

    Catat setiap panggilan API untuk monitoring dan debugging:

    import logging
    

    import time

    logging.basicConfig(level=logging.INFO)

    logger = logging.getLogger("aisuite")

    def loggedcompletion(client, model, messages, kwargs):

    """Completion dengan logging lengkap."""

    start = time.time()

    logger.info(f"Request ke {model} - {len(messages)} messages")

    try:

    response = client.chat.completions.create(

    model=model, messages=messages, kwargs

    )

    elapsed = time.time() - start

    content = response.choices[0].message.content

    logger.info(f"Response dari {model} - {len(content)} chars - {elapsed:.2f}s")

    return content

    except Exception as e:

    elapsed = time.time() - start

    logger.error(f"Error dari {model} setelah {elapsed:.2f}s: {e}")

    raise

    5. Batasi Concurrency

    Saat melakukan batch processing, batasi jumlah request paralel agar tidak melebihi rate limit:

    from concurrent.futures import ThreadPoolExecutor
    

    import time

    MAXCONCURRENT = 5

    RATELIMITDELAY = 0.5

    def batchprocess(client, prompts, model, maxworkers=MAXCONCURRENT):

    """Batch processing dengan rate limiting."""

    results = []

    with ThreadPoolExecutor(maxworkers=maxworkers) as executor:

    futures = []

    for i, prompt in enumerate(prompts):

    messages = [{"role": "user", "content": prompt}]

    future = executor.submit(

    client.chat.completions.create,

    model=model,

    messages=messages

    )

    futures.append((i, future))

    time.sleep(RATELIMITDELAY)

    for i, future in futures:

    try:

    response = future.result(timeout=60)

    results.append({

    "index": i,

    "content": response.choices[0].message.content,

    "success": True

    })

    except Exception as e:

    results.append({

    "index": i,

    "content": str(e),

    "success": False

    })

    return sorted(results, key=lambda x: x["index"])

    Studi Kasus: Membangun Multi-LLM Chatbot

    Berikut contoh lengkap membangun chatbot sederhana yang mendukung pemilihan model secara dinamis:

    import aisuite as ai
    
    

    client = ai.Client()

    AVAILABLEMODELS = {

    "1": ("openai:gpt-4o", "GPT-4o (OpenAI)"),

    "2": ("anthropic:claude-sonnet-4-6", "Claude Sonnet 4.6 (Anthropic)"),

    "3": ("google:gemini-2.0-flash", "Gemini 2.0 Flash (Google)"),

    "4": ("groq:llama-3.3-70b-versatile", "Llama 3.3 70B (Groq)")

    }

    def runchatbot():

    print("=== Multi-LLM Chatbot ===")

    print("Pilih model:")

    for key, (, name) in AVAILABLEMODELS.items():

    print(f" {key}. {name}")

    choice = input("\nPilihan (1-4): ").strip()

    model, modelname = AVAILABLEMODELS.get(choice, AVAILABLEMODELS["1"])

    print(f"\nMenggunakan: {modelname}")

    print("Ketik 'quit' untuk keluar, 'switch' untuk ganti model.\n")

    conversation = [

    {"role": "system", "content": "Kamu adalah asisten AI yang helpful. Jawab dalam bahasa Indonesia."}

    ]

    while True:

    userinput = input("Anda: ").strip()

    if userinput.lower() == "quit":

    break

    if userinput.lower() == "switch":

    print("\nPilih model:")

    for key, (, name) in AVAILABLEMODELS.items():

    print(f" {key}. {name}")

    choice = input("Pilihan: ").strip()

    model, modelname = AVAILABLEMODELS.get(choice, (model, modelname))

    print(f"Beralih ke: {modelname}\n")

    continue

    conversation.append({"role": "user", "content": userinput})

    try:

    response = client.chat.completions.create(

    model=model,

    messages=conversation,

    temperature=0.7

    )

    assistantmessage = response.choices[0].message.content

    conversation.append({"role": "assistant", "content": assistantmessage})

    print(f"\n{modelname}: {assistantmessage}\n")

    except Exception as e:

    print(f"\nError: {e}\n")

    if name == "main":

    runchatbot()

    Tips Tambahan

    Memilih Model yang Tepat

    Setiap model memiliki kekuatan yang berbeda:

    • GPT-4o: Bagus untuk tugas umum, coding, dan reasoning
    • Claude Sonnet: Sangat baik untuk penulisan, analisis panjang, dan kepatuhan instruksi
    • Gemini Flash: Cepat dan efisien untuk tugas yang membutuhkan respons singkat
    • Llama (via Groq): Latensi rendah, bagus untuk aplikasi real-time
    • Mistral Large*: Performa yang baik untuk tugas multilingual

    Perkiraan Biaya

    Gunakan aisuite untuk memperkirakan biaya sebelum menjalankan batch besar:

    COSTPER1KTOKENS = {
    

    "openai:gpt-4o": {"input": 0.0025, "output": 0.01},

    "openai:gpt-4o-mini": {"input": 0.00015, "output": 0.0006},

    "anthropic:claude-sonnet-4-6": {"input": 0.003, "output": 0.015},

    "google:gemini-2.0-flash": {"input": 0.0001, "output": 0.0004},

    }

    def estimatecost(model, numrequests, avginputtokens=500, avgoutputtokens=300):

    costs = COSTPER1KTOKENS.get(model, {"input": 0, "output": 0})

    totalinput = (numrequests avginputtokens / 1000) costs["input"]

    totaloutput = (numrequests avgoutputtokens / 1000) * costs["output"]

    return round(totalinput + totaloutput, 4)

    Contoh: estimasi biaya untuk 1000 request

    for model in COSTPER1KTOKENS:

    cost = estimatecost(model, 1000)

    print(f"{model}: ~${cost} untuk 1000 requests")

    Kesimpulan

    Aisuite adalah solusi yang elegan untuk masalah umum yang dihadapi developer AI: mengelola integrasi dengan berbagai LLM provider. Dengan unified interface yang mengikuti standar OpenAI Chat Completions, library ini membuat pekerjaan menjadi lebih efisien tanpa mengorbankan fleksibilitas.

    Poin-poin utama yang perlu diingat:

    • Aisuite menyederhanakan penggunaan multi-LLM melalui satu interface seragam
    • Format model identifier provider:model_name memudahkan perpindahan antar provider
    • Library ini mendukung lebih dari 10 provider termasuk OpenAI, Anthropic, Google, dan AWS
    • Cocok untuk evaluasi model, fallback pattern, dan membangun aplikasi AI yang resilient
    • Tetap ikuti best practices: gunakan environment variable, implementasi error handling, dan perhatikan rate limit

    Untuk informasi lebih lanjut, kunjungi repository resmi aisuite di GitHub: github.com/andrewyng/aisuite.

    Artikel Terkait

    Tutorial Lengkap Jupyter AI: Integrasikan LLM Langsung ke Notebook Anda

    Tutorial Lengkap Jupyter AI: Integrasikan LLM Langsung ke Notebook Anda Jupyter Notebook telah menjadi alat utama bagi d...

    Tutorial Lengkap Anthropic Claude API: Dari Dasar hingga Fitur Lanjutan

    Tutorial Lengkap Anthropic Claude API: Dari Dasar hingga Fitur Lanjutan Anthropic Claude adalah salah satu Large Languag...

    Tutorial ScrapeGraphAI: Web Scraping Cerdas dengan LLM dan Graph Logic

    Tutorial ScrapeGraphAI: Web Scraping Cerdas dengan LLM dan Graph Logic Pendahuluan Web scraping adalah salah satu teknik...

    Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom

    Tutorial MergeKit: Menggabungkan Model LLM untuk Membuat Model AI Kustom Model bahasa besar (LLM) open-source terus berk...