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:
openai:gpt-4o menjadi anthropic:claude-sonnet-4-6Instalasi
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 cached
completion(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 estimate
cost(model, numrequests, avginputtokens=500, avgoutputtokens=300):
costs = COST
PER1KTOKENS.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_namememudahkan 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.