LiteLLM: Panduan dengan Contoh Praktis

Beralih antar penyedia LLM tidak seharusnya mengharuskan Anda menulis ulang seluruh basis kode. Namun itulah yang sering terjadi saat Anda bekerja dengan banyak layanan AI saat ini. Setiap penyedia punya SDK, metode autentikasi, dan format respons yang berbeda-beda. LiteLLM menyelesaikan ini dengan antarmuka terpadu.

Dalam tutorial ini, saya akan menjelaskan bagian-bagian utama LiteLLM dan menunjukkan cara memulai dari panggilan API dasar hingga respons streaming, output terstruktur, dan pelacakan biaya.

Apa Itu LiteLLM?

LiteLLM adalah pustaka Python open-source yang berfungsi sebagai penerjemah universal untuk model AI. Alih-alih mempelajari API yang berbeda untuk setiap penyedia, Anda menggunakan satu antarmuka yang terhubung ke lebih dari 100 layanan LLM.

Kerangka kerja ini memiliki dua bagian utama. SDK Python memungkinkan Anda menulis kode sekali dan menjalankannya dengan penyedia mana pun. Proxy server bertindak sebagai gerbang pusat bagi tim dan perusahaan yang perlu mengelola layanan AI dalam skala besar.

LiteLLM memberi Anda manfaat tambahan berikut:

• Pelacakan biaya bawaan: Lihat pengeluaran di semua penyedia dalam satu dasbor alih-alih memeriksa banyak sistem penagihan
• Failover otomatis: Ketika satu penyedia down atau terkena batas laju, LiteLLM otomatis mencoba opsi cadangan Anda
• Opsi self-hosting: Jalankan semuanya di server Anda sendiri jika Anda memerlukan privasi data atau kepatuhan

Perlu dicatat bahwa OpenRouter menyediakan akses terpadu yang serupa ke banyak LLM, meskipun dengan harga dan fitur yang berbeda.

Proxy server menambahkan batas pengeluaran per tim, pelacakan penggunaan lintas proyek, dan manajemen kunci API terpusat. Semua konfigurasi dilakukan melalui file YAML sederhana.

LiteLLM cocok untuk berbagai jenis pengguna:

• Pengembang individu yang ingin menguji banyak model tanpa harus membuat akun di mana-mana
• Tim kecil yang membutuhkan visibilitas biaya dan tidak ingin terikat vendor
• Perusahaan besar yang memerlukan manajemen terpusat, kontrol anggaran, dan analitik penggunaan terperinci

Pustaka ini berlisensi MIT dan sepenuhnya open-source. Anda dapat memeriksa kodenya, memodifikasinya sesuai kebutuhan, atau berkontribusi kembali ke proyek.

Sekarang setelah Anda tahu apa yang dapat dilakukan LiteLLM, berikut cara menyiapkan lingkungan Anda.

Prasyarat

Sebelum mulai menggunakan LiteLLM, Anda perlu menyiapkan beberapa hal. Sebagian besar ini mungkin sudah ada jika Anda pernah bekerja dengan model AI sebelumnya.

Lingkungan Python

Anda memerlukan Python 3.7 atau yang lebih baru. Sebagian besar sistem saat ini sudah memilikinya, tetapi Anda dapat memeriksa versi Anda dengan:

import sys
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")Didukung oleh

Instalasi paket

Instal LiteLLM dan python-dotenv untuk mengelola variabel lingkungan:

uv add litellm python-dotenv
# or with pip: pip install litellm python-dotenvDidukung oleh

Kunci API

Anda memerlukan kunci API dari penyedia yang ingin digunakan. Untuk tutorial ini, kita akan bekerja dengan dua model:

• Kunci API OpenAI: Anda bisa mendapatkan kunci dari platform.openai.com (untuk GPT-5)
• Kunci API Anthropic: Anda bisa mendapatkan kunci dari console.anthropic.com (untuk Claude Sonnet 4)

Simpan ini dalam file .env di direktori proyek Anda:

OPENAI_API_KEY=your_openai_key_here
ANTHROPIC_API_KEY=your_anthropic_key_hereDidukung oleh

Pemeriksaan lingkungan

Jalankan skrip ini untuk memeriksa setelan Anda:

import os
import sys
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Check Python version
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")

# Check LiteLLM
try:
   import litellm
   print("✓ LiteLLM installed")
except ImportError:
   print("✗ LiteLLM not installed")

# Check API keys
openai_key = os.getenv("OPENAI_API_KEY")
anthropic_key = os.getenv("ANTHROPIC_API_KEY")

if openai_key:
   print(f"✓ OpenAI API key found")
else:
   print("✗ OpenAI API key not found")

if anthropic_key:
   print(f"✓ Anthropic API key found")
else:
   print("✗ Anthropic API key not found")Didukung oleh

Python version: 3.11
✓ LiteLLM installed
✓ OpenAI API key found
✓ Anthropic API key foundDidukung oleh

Jika Anda melihat semua tanda centang hijau, Anda siap melanjutkan. Jika ada pemeriksaan yang gagal, pastikan Anda telah memasang paket dan menambahkan kunci API ke file .env.

Membuat Panggilan API Pertama Anda dengan LiteLLM

LiteLLM menggunakan antarmuka yang sama seperti yang mungkin Anda kenal dari OpenAI, tetapi berfungsi dengan penyedia mana pun.

Penyiapan dasar

Mulai dengan impor berikut:

import litellm
from dotenv import load_dotenv

# Load your API keys
load_dotenv()Didukung oleh

Permintaan dasar ke GPT-5 mengikuti pola ini: definisikan pesan Anda, panggil litellm.completion(), dan ambil responsnya.

messages = [
   {"role": "user", "content": "Write a simple Python function that adds two numbers"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

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

def add(a, b):
   """Return the sum of a and b."""
   return a + bDidukung oleh

Anda baru saja memanggil GPT-5 melalui LiteLLM. Objek respons mengikuti format OpenAI, jadi jika Anda pernah menggunakan API mereka sebelumnya, ini akan terlihat familier. Anda mungkin ingin memeriksa model mana yang sebenarnya merespons dan memeriksa penggunaan token:

print(f"Model used: {response.model}")
print(f"Response ID: {response.id}")
print(f"Total tokens: {response.usage.total_tokens}")Didukung oleh

Model used: gpt-5-2025-08-07
Response ID: chatcmpl-CIbZWUDE1amW2vHtHDmieTX6hnZUq
Total tokens: 557Didukung oleh

Beralih penyedia

Kekuatan nyata LiteLLM terlihat saat beralih penyedia. Ingin mencoba Claude Sonnet 4 sebagai gantinya? Ubah satu parameter:

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages
)

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

Here's a simple Python function that adds two numbers:

def add_numbers(a, b):
   """
   Adds two numbers and returns the result.
  
   Args:
       a: First number
       b: Second number
  
   Returns:
       The sum of a and b
   """
   return a + b

# Example usage:
result = add_numbers(5, 3)
print(result)  # Output: 8

This function:
- Takes two parameters a and b
- Returns their sum using the + operator
- Works with integers, floats, and even negative numbers
- Includes a docstring to explain what the function doesDidukung oleh

Struktur kode sama, penyedia berbeda. Claude memberikan respons yang jauh lebih detail dengan dokumentasi dan contoh, sementara GPT-5 lebih ringkas.

Penanganan error dasar

Tambahkan sedikit penanganan error untuk saat sesuatu berjalan salah:

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages
   )
   print(response.choices[0].message.content)
except Exception as e:
   print(f"API call failed: {e}")Didukung oleh

Pola ini menangkap masalah umum seperti kunci API tidak valid, masalah jaringan, atau model tidak tersedia.

Langkah berikutnya

Sekarang Anda memahami pola dasar penggunaan LiteLLM dengan penyedia mana pun. Dokumentasi Getting Started membahas lebih detail tentang model dan parameter yang didukung, dan referensi fungsi Completion menampilkan semua opsi yang tersedia.

Untuk membangun aplikasi produksi, Anda juga perlu mengikuti praktik terbaik desain API guna menciptakan sistem yang andal dan berkinerja tinggi.

Peralihan Penyedia dan Fallback

Sistem fallback LiteLLM secara otomatis menangani kegagalan penyedia sehingga pengguna Anda tidak pernah melihat pesan error. Saat membangun aplikasi nyata, Anda memerlukan rencana cadangan yang berfungsi tanpa kode tambahan dari pihak Anda.

Penyiapan fallback dasar

Untuk menyiapkan fallback, tambahkan daftar fallbacks ke panggilan completion Anda:

messages = [
   {"role": "user", "content": "Explain what a Python decorator is in one sentence"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514"]
)

print(f"Response: {response.choices[0].message.content}")
print(f"Model used: {response.model}")Didukung oleh

Response: A Python decorator is a callable that wraps another function or class to augment its behavior and returns it, applied with the @ syntax so you can add reusable functionality without changing the original code.
Model used: gpt-5-2025-08-07Didukung oleh

Jika GPT-5 gagal, LiteLLM otomatis mencoba Claude Sonnet 4. Pengguna tetap mendapatkan respons.

Membangun rantai fallback

Anda dapat merangkai beberapa penyedia untuk keandalan yang lebih baik. Menggunakan pesan yang sama seperti sebelumnya:

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514", "gpt-3.5-turbo"]
)

print(f"Model used: {response.model}")Didukung oleh

Model used: gpt-5-2025-08-07Didukung oleh

LiteLLM mencoba model sesuai urutan. Jika utama gagal, ia mencoba fallback pertama. Jika itu gagal, ia mencoba yang kedua. Beberapa lapisan perlindungan.

Menambahkan retry

Gabungkan fallback dengan retry untuk keandalan yang lebih baik lagi:

response = litellm.completion(
   model="gpt-5",
   messages=messages,  # Same messages as before
   num_retries=2
)Didukung oleh

Mencoba ulang model yang sama dua kali sebelum beralih ke fallback. Cocok untuk masalah jaringan sementara atau lonjakan rate limit.

Fallback menangani sebagian besar kegagalan secara otomatis, tetapi Anda tetap harus menangkap kasus ketika semua model gagal:

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages,  # Same messages as before
       fallbacks=["anthropic/claude-sonnet-4-20250514"],
       num_retries=2
   )
   return response.choices[0].message.content
except Exception as e:
   # All models failed - handle gracefully
   return "Sorry, I'm having trouble right now. Please try again."Didukung oleh

Bahkan ketika penyedia berfungsi sempurna, pengguna masih menghadapi masalah lain: waktu tunggu yang membuat frustrasi. Seseorang mengklik kirim di aplikasi Anda dan tidak melihat apa pun selama beberapa detik. Mereka bertanya-tanya apakah ada yang rusak.

Streaming untuk Respons Real-Time

Sebagian besar respons API AI datang sebagai satu blok lengkap, seperti mengunduh file. Pengguna menunggu tanpa umpan balik sampai seluruh respons siap. Streaming mengubah ini dengan menampilkan teks saat dihasilkan, kata demi kata.

Mengapa streaming mengubah pengalaman pengguna

Alih-alih menunggu respons lengkap, streaming menampilkan teks saat AI menghasilkannya. Lihat perbedaannya:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "What is Python in one sentence?"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   stream=True
)

for chunk in response:
   if chunk.choices[0].delta.content:
       print(chunk.choices[0].delta.content, end="", flush=True)Didukung oleh

Python is a high-level, interpreted, dynamically typed, general-purpose programming language known for its readability and vast ecosystem, used across web development, data science, automation, scripting, and more.Didukung oleh

Teks muncul bertahap alih-alih sekaligus (saat menjalankan cuplikan di atas di mesin Anda). Pengguna melihat progres segera, yang terasa jauh lebih responsif daripada menatap pemintal pemuatan.

Cara kerja streaming sebenarnya

Ini bekerja pada level potongan. Alih-alih satu respons besar, Anda mendapatkan banyak bagian kecil, disebut delta. Terkadang, chunk kosong, jadi Anda harus menanganinya dengan benar demi keamanan:

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=[{"role": "user", "content": "Define JavaScript in exactly two sentences"}],
   stream=True
)

for chunk in response:
   if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
       print(f"'{chunk.choices[0].delta.content}'", end=" ")Didukung oleh

'JavaScript is a high' '-level, interpreted programming language primarily used for creating' ' interactive and dynamic content on web pages, running' ' in web browsers to manip' 'ulate HTML elements, handle user events' ', and communicate with servers.' ' Originally designed for client-side web development, JavaScript has evolve' 'd into a versatile language that can also' ' be used for server-side development, mobile applications' ', and desktop software through various runtime' ' environments like Node.js.'Didukung oleh

Membuat streaming dapat digunakan ulang

Untuk aplikasi nyata, Anda ingin menangkap respons lengkap sambil tetap menampilkan output streaming. Berikut fungsi untuk melakukannya:

def stream_and_capture(model, messages):
   """Stream response while capturing the complete text"""
   response = litellm.completion(
       model=model,
       messages=messages,
       stream=True
   )
  
   full_response = ""
   for chunk in response:
       if chunk.choices[0].delta.content:
           content = chunk.choices[0].delta.content
           print(content, end="", flush=True)
           full_response += content
  
   print()  # New line after response
   return full_response

# Test it
messages = [{"role": "user", "content": "Define APIs in 2 sentences max"}]
result = stream_and_capture("gpt-5", messages)Didukung oleh

APIs (Application Programming Interfaces) are standardized contracts, often exposed as endpoints, that specify how software components or services can communicate, including the allowed operations, inputs, and outputs. They let developers access functionality or data without knowing the underlying implementation, enabling modular, interoperable systems.Didukung oleh

Parameter end="" mencegah pemisah baris antar chunk. flush=True memaksa tampilan langsung alih-alih buffering.

Streaming dengan fallback

Anda juga dapat menggabungkan streaming dengan sistem fallback untuk keandalan yang lebih baik:

response = litellm.completion(
   model="gpt-5",
   messages=[{"role": "user", "content": "Define machine learning in one sentence"}],
   fallbacks=["anthropic/claude-sonnet-4-20250514"],
   stream=True
)

for chunk in response:
   if chunk.choices[0].delta.content:
       print(chunk.choices[0].delta.content, end="", flush=True)Didukung oleh

Machine learning is a branch of artificial intelligence where algorithms learn patterns from data to make predictions or decisions without being explicitly programmed.Didukung oleh

Umpan balik instan ditambah peralihan penyedia otomatis jika model utama gagal.

Streaming memberi pengguna umpan balik segera, tetapi Anda masih menghadapi masalah lain saat membangun aplikasi nyata. Setelah teks tiba, kode Anda perlu bekerja dengannya. Anda mungkin mengekstrak data, menyimpan informasi di basis data, atau meneruskan nilai ke fungsi lain. Namun mengurai respons teks itu berantakan dan mudah rusak saat format berubah.

Menggunakan Output Terstruktur

Inilah yang sebenarnya terjadi: Anda membuat aplikasi yang menganalisis umpan balik pelanggan. AI Anda mengembalikan teks seperti “Sentimennya positif dengan kepercayaan 0,85 dan kata kunci utama: responsif, membantu, cepat.” Anda menulis pola regex untuk mengekstrak skor kepercayaan dan kata kunci. Semuanya berfungsi saat pengujian.

Lalu AI sedikit mengubah format respons menjadi “Sentiment: positive (confidence: 0.85). Keywords include responsive, helpful, and fast.” Regex Anda rusak. Alur data Anda berhenti bekerja. Laporan sentimen pelanggan menampilkan nilai kosong alih-alih skor. Dasbor Anda crash. Anda menghabiskan berjam-jam memperbaiki kode parsing yang kemarin berfungsi.

Output terstruktur melewati masalah ini dengan mengembalikan data dalam format yang dapat diprediksi sejak awal.

Mendapatkan JSON alih-alih teks

LiteLLM dapat mengembalikan JSON alih-alih teks biasa. Anda memberi tahu strukturnya melalui prompt, dan hasilnya kembali dengan format yang benar:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Describe Python as a programming language. Return as JSON with fields: language, difficulty, description"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

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

{
 "language": "Python",
 "difficulty": "Beginner-friendly (easy to learn, moderate to master)",
 "description": "Python is a high-level, interpreted, dynamically typed, general-purpose programming language focused on readability and developer productivity. It supports multiple paradigms (object-oriented, functional, procedural), uses indentation for block structure, and includes a large standard library with an extensive third-party ecosystem (PyPI). Common uses include web development, data science, machine learning, automation/scripting, scientific computing, and DevOps. While not the fastest for CPU-bound tasks, it integrates well with C/C++ and accelerators, and runs cross-platform."
}Didukung oleh

Pendekatan terstruktur ini menghilangkan masalah parsing umum. Alih-alih menyisir teks, Anda mendapatkan JSON valid dengan tepat field yang diminta. Tanpa pusing parsing, tanpa kejutan format.

Bekerja dengan data JSON

String JSON mentah tidak berguna sampai Anda mengonversinya ke objek Python yang dapat digunakan aplikasi Anda. Anda perlu mengubah string itu menjadi objek Python yang benar-benar bisa dipakai:

import json

messages = [{"role": "user", "content": "Describe JavaScript in 2 sentences. Return as JSON with fields: name, paradigm, use_cases (array of exactly 3 items)"}]

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse the JSON response
data = json.loads(response.choices[0].message.content)
print(f"Language: {data['name']}")
print(f"Paradigm: {data['paradigm']}")
print(f"Use cases: {', '.join(data['use_cases'])}")Didukung oleh

Language: JavaScript
Paradigm: multi-paradigm (object-oriented, functional, event-driven)
Use cases: web development and browser scripting, server-side development with Node.js, mobile app development with frameworks like React NativeDidukung oleh

Sekarang setelah Anda memiliki data terstruktur, Anda dapat meneruskannya langsung ke fungsi lain, menyimpannya di basis data, atau menampilkannya di UI tanpa manipulasi teks. Untuk alur kerja analisis data, alat seperti Pandas AI dapat bekerja langsung dengan output terstruktur ini untuk menghasilkan insight.

Menambahkan keamanan tipe dengan Pydantic

Parsing JSON menangkap error sintaks, tetapi tipe data yang salah atau field yang hilang adalah masalah berbeda. Model Pydantic memecahkan ini dengan memvalidasi struktur data Anda dan menangkap masalah sebelum merusak aplikasi Anda:

from pydantic import BaseModel
import json

class ProgrammingLanguage(BaseModel):
   name: str
   paradigm: str
   use_cases: list[str]

messages = [{"role": "user", "content": "Describe CSS briefly. Return as JSON with fields: name, paradigm, use_cases (array of 3 items)"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse and validate with Pydantic
data = json.loads(response.choices[0].message.content)
language = ProgrammingLanguage(**data)

print(f"Validated data: {language.name} - {language.paradigm}")
print(f"Use cases: {language.use_cases}")Didukung oleh

Validated data: CSS (Cascading Style Sheets) - Declarative, rule-based stylesheet language for describing the presentation of structured documents.
Use cases: ['Styling layout, colors, and typography of web pages', 'Responsive design across devices and viewports', 'Animations, transitions, and visual effects']Didukung oleh

Pydantic secara otomatis memvalidasi bahwa name dan paradigm adalah string, dan use_cases adalah daftar string. Jika AI mengembalikan tipe yang salah atau melupakan field wajib, Anda akan mendapatkan error yang jelas alih-alih bug misterius di kemudian hari.

Menangani error JSON

Parsing JSON dapat gagal jika AI mengembalikan JSON yang salah format atau teks non-JSON. Tambahkan penanganan error dasar:

import json

messages = [{"role": "user", "content": "Summarize machine learning in 1 sentence. Return as JSON with topic and summary fields"}]

try:
   response = litellm.completion(
       model="anthropic/claude-sonnet-4-20250514",
       messages=messages,
       response_format={"type": "json_object"}
   )
  
   data = json.loads(response.choices[0].message.content)
   print(f"Topic: {data['topic']}")
   print(f"Summary: {data['summary']}")
  
except json.JSONDecodeError:
   print("Invalid JSON returned")
except Exception as e:
   print(f"Request failed: {e}")Didukung oleh

Topic: machine learning
Summary: Machine learning is a subset of artificial intelligence that allows computers to learn and make predictions or decisions from data without being explicitly programmed for each specific task.Didukung oleh

Output terstruktur menggantikan parsing teks yang berantakan dengan struktur data yang bersih. Anda dapat menggabungkan mode JSON dengan fallback sama seperti completion biasa.

Output terstruktur memberi Anda data yang bersih dan dapat diprediksi yang tidak akan merusak logika parsing Anda. Namun ada masalah lain saat Anda beralih dari prototipe ke produksi: tagihan. Setiap panggilan API berbiaya, dan biaya tersebut bisa mengejutkan Anda.

Pelacakan Biaya

Begini yang terjadi: Prototipe Anda berjalan sangat baik saat pengujian dengan 50 panggilan API per hari. Anda menghabiskan sekitar $2 per minggu. Semuanya terlihat baik-baik saja. Anda meluncurkan ke produksi dan mendapatkan 500 pengguna. Sekarang Anda membuat 5.000 panggilan API per hari. Tagihan bulanan Anda melonjak dari $8 menjadi $800.

Tanpa pelacakan biaya, Anda tidak mendapatkan peringatan. Anda tidak tahu fitur mana yang paling mahal, model mana yang lebih mahal, atau bagaimana menganggarkan untuk pertumbuhan. Anda baru mengetahui lonjakan tagihan berminggu-minggu kemudian saat menerima tagihan kartu kredit.

LiteLLM melacak secara tepat apa yang Anda belanjakan di semua penyedia.

Memahami penggunaan token

Setiap respons AI mencakup informasi penggunaan terperinci yang menunjukkan secara tepat apa yang Anda bayar:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Explain what a REST API is in two sentences"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

print(f"Response: {response.choices[0].message.content}")
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")
print(f"Total tokens: {response.usage.total_tokens}")Didukung oleh

Response: A REST API is a web service that follows the Representational State Transfer architectural style, exposing resources identified by URLs and manipulated with HTTP methods like GET, POST, PUT, and DELETE. It uses stateless client-server communication, cacheability, and uniform representations (often JSON) to support scalable, decoupled interactions.
Prompt tokens: 15
Completion tokens: 201
Total tokens: 216Didukung oleh

Token input adalah prompt Anda, token output adalah respons AI. Penyedia yang berbeda mengenakan tarif yang berbeda untuk masing-masing jenis.

Perhitungan biaya otomatis

Jumlah token mentah tidak memberi tahu Anda nilai dolar. LiteLLM menghitung biaya sebenarnya untuk Anda:

# Get the cost for a completed response
cost = litellm.completion_cost(completion_response=response)
print(f"Total cost: ${cost:.4f}")
Total cost: $0.0020Didukung oleh

Basis data harga LiteLLM mengonversi token menjadi dolar berdasarkan model Anda.

Perhitungan biaya manual

Terkadang Anda ingin memperkirakan biaya sebelum melakukan panggilan, atau menghitung biaya untuk teks yang sudah Anda miliki:

# Calculate cost without making an API call
prompt_text = "Explain machine learning"
completion_text = "Machine learning is a method of data analysis that automates analytical model building."

estimated_cost = litellm.completion_cost(
   model="anthropic/claude-sonnet-4-20250514",
   prompt=prompt_text,
   completion=completion_text
)

print(f"Estimated cost: ${estimated_cost:.4f}")Didukung oleh

Estimated cost: $0.0002Didukung oleh

Ini berguna untuk penganggaran dan membandingkan model.

Melacak banyak panggilan API

Untuk aplikasi yang melakukan banyak panggilan API, Anda dapat melacak biaya kumulatif:

total_cost = 0.0

conversation = [
   "What is Python?",
   "How do you install Python packages?",
   "What are virtual environments?"
]

for i, question in enumerate(conversation):
   response = litellm.completion(
       model="gpt-5",
       messages=[{"role": "user", "content": question}]
   )
  
   call_cost = litellm.completion_cost(completion_response=response)
   total_cost += call_cost
  
   print(f"Call {i+1}: ${call_cost:.4f}")

print(f"Total cost: ${total_cost:.4f}")Didukung oleh

Call 1: $0.0057
Call 2: $0.0134
Call 3: $0.0102
Total cost: $0.0292Didukung oleh

Pelacakan biaya membantu Anda membuat keputusan yang tepat tentang model mana yang digunakan dan menghindari tagihan mengejutkan. Lihat secara persis biaya setiap panggilan API dan bandingkan penyedia.

Kesimpulan

Sekarang Anda memiliki alat untuk membangun aplikasi AI tanpa terkunci pada vendor. Anda telah mempelajari panggilan API dasar, fallback otomatis, respons streaming, output terstruktur, dan pelacakan biaya.

Ini memberi Anda kebebasan untuk memilih model terbaik untuk setiap tugas. Beralih penyedia dengan mudah, atur fallback otomatis, dan lacak biaya. Saat model yang lebih baik hadir, Anda dapat mengadopsinya tanpa menulis ulang kode.