LiteLLM: Universal API Gateway untuk 100+ Model LLM

Dalam dunia AI yang berkembang pesat, kita dihadapkan dengan puluhan penyedia LLM (Large Language Model) seperti OpenAI, Anthropic, Google Gemini, Cohere, Ollama, dan masih banyak lagi. Setiap penyedia memiliki format API, autentikasi, dan parameter yang berbeda-beda. Bayangkan jika Anda bisa memanggil semua model tersebut dengan satu interface yang seragam. Itulah yang ditawarkan oleh LiteLLM.

LiteLLM adalah library Python open-source yang menyediakan unified interface untuk memanggil 100+ model LLM menggunakan format OpenAI API. Dengan LiteLLM, Anda cukup menulis kode sekali dan bisa berpindah antar provider tanpa mengubah kode sama sekali.

Mengapa LiteLLM?

Berikut beberapa alasan mengapa LiteLLM menjadi pilihan populer:

• Unified API: Satu format pemanggilan untuk semua provider
• 100+ Model: Mendukung OpenAI, Anthropic, Google, Cohere, Ollama, HuggingFace, dan lainnya
• OpenAI-Compatible Proxy: Jalankan proxy server yang kompatibel dengan OpenAI API
• Fallback & Retry: Otomatis berpindah ke model lain jika satu model gagal
• Cost Tracking: Lacak biaya penggunaan setiap model
• Load Balancing: Distribusikan request ke beberapa model/provider
• Streaming: Dukungan streaming response bawaan
• Production Ready: Router untuk deployment produksi skala besar

Instalasi dan Setup

Instalasi LiteLLM

Instal LiteLLM menggunakan pip:

pip install litellm

Untuk fitur proxy server, instal dengan dependensi tambahan:

pip install 'litellm[proxy]'

Konfigurasi API Key

Sebelum mulai, siapkan API key dari provider yang ingin Anda gunakan. Simpan sebagai environment variable:

# OpenAI
export OPENAIAPIKEY="sk-your-openai-key"

Anthropic
export ANTHROPICAPIKEY="sk-ant-your-anthropic-key"

Google Gemini
export GEMINIAPIKEY="your-gemini-key"

Atau gunakan file .env

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

from dotenv import loaddotenv
loaddotenv()

Basic Completion Calls

Memanggil OpenAI GPT

import litellm

Panggil OpenAI GPT-4o
response = litellm.completion(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Kamu adalah asisten yang membantu."},
        {"role": "user", "content": "Jelaskan apa itu machine learning dalam 2 kalimat."}
    ]
)

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

Memanggil Anthropic Claude

# Panggil Anthropic Claude - cukup ganti nama model!
response = litellm.completion(
    model="anthropic/claude-sonnet-4-20250514",
    messages=[
        {"role": "user", "content": "Jelaskan apa itu neural network dalam 2 kalimat."}
    ]
)

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

Memanggil Google Gemini

# Panggil Google Gemini
response = litellm.completion(
    model="gemini/gemini-2.0-flash",
    messages=[
        {"role": "user", "content": "Apa perbedaan supervised dan unsupervised learning?"}
    ]
)

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

Memanggil Ollama (Model Lokal)

# Panggil model lokal via Ollama
response = litellm.completion(
    model="ollama/llama3",
    messages=[
        {"role": "user", "content": "Tulis fungsi Python untuk menghitung fibonacci."}
    ],
    apibase="http://localhost:11434"

)

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

import litellm

def tanyaai(pertanyaan: str, model: str = "gpt-4o") -> str:
    """Fungsi universal untuk bertanya ke AI model mana pun."""
    response = litellm.completion(
        model=model,
        messages=[
            {"role": "user", "content": pertanyaan}
        ],
        temperature=0.7,
        maxtokens=1000

    )
    return response.choices[0].message.content

Gunakan dengan provider berbeda - kode yang sama!
pertanyaan = "Apa itu API Gateway?"

OpenAI
jawabanopenai = tanyaai(pertanyaan, model="gpt-4o")

print(f"OpenAI: {jawabanopenai}\n")

Anthropic
jawabanclaude = tanyaai(pertanyaan, model="anthropic/claude-sonnet-4-20250514")
print(f"Claude: {jawabanclaude}\n")


Gemini
jawabangemini = tanyaai(pertanyaan, model="gemini/gemini-2.0-flash")

print(f"Gemini: {jawabangemini}\n")

Ollama (lokal)
jawabanollama = tanyaai(pertanyaan, model="ollama/llama3")
print(f"Ollama: {jawabanollama}\n")

Perhatikan bahwa format messages, temperature, dan maxtokens semuanya seragam. LiteLLM secara otomatis menerjemahkan parameter ini ke format yang dipahami masing-masing provider.

LiteLLM Proxy Server

LiteLLM Proxy Server memungkinkan Anda menjalankan server yang kompatibel dengan OpenAI API. Ini berarti aplikasi apa pun yang sudah mendukung OpenAI API bisa langsung terhubung ke 100+ model melalui proxy ini.

Konfigurasi Proxy

Buat file litellmconfig.yaml:

modellist:
modelname: gpt-4o

    litellmparams:

      model: gpt-4o
      apikey: sk-your-openai-key

modelname: claude-sonnet
    litellmparams:

      model: anthropic/claude-sonnet-4-20250514
      apikey: sk-ant-your-anthropic-key
modelname: gemini-flash

    litellmparams:

      model: gemini/gemini-2.0-flash
      apikey: your-gemini-key

modelname: llama-local
    litellmparams:

      model: ollama/llama3
      apibase: http://localhost:11434

litellmsettings:

  dropparams: true
  setverbose: false

litellm --config litellmconfig.yaml --port 4000

Menggunakan Proxy dari Client

Sekarang Anda bisa menggunakan OpenAI SDK standar yang mengarah ke proxy:

from openai import OpenAI

Arahkan ke LiteLLM Proxy
client = OpenAI(
    apikey="sk-anything",  # proxy tidak memvalidasi key secara default

    baseurl="http://localhost:4000"
)

Panggil Claude melalui OpenAI-compatible endpoint!
response = client.chat.completions.create(
    model="claude-sonnet",
    messages=[
        {"role": "user", "content": "Halo, siapa kamu?"}
    ]
)
print(response.choices[0].message.content)

Ini sangat berguna untuk:

• Tim yang ingin menggunakan satu endpoint untuk semua model
• Aplikasi yang sudah terintegrasi dengan OpenAI API
• Mengontrol akses dan biaya secara terpusat

Streaming Responses

Streaming memungkinkan Anda menerima response secara bertahap (token per token), yang memberikan pengalaman pengguna yang lebih responsif:

import litellm

Streaming dengan OpenAI
response = litellm.completion(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Tulis cerita pendek tentang robot yang belajar memasak."}
    ],
    stream=True
)

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

print()  # Newline di akhir

Streaming juga bekerja dengan semua provider:

# Streaming dengan Anthropic Claude
response = litellm.completion(
    model="anthropic/claude-sonnet-4-20250514",
    messages=[
        {"role": "user", "content": "Jelaskan konsep recursion dengan analogi."}
    ],
    stream=True
)

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

Fallbacks dan Retries

Dalam produksi, Anda perlu menangani kasus ketika satu provider mengalami masalah. LiteLLM menyediakan mekanisme fallback yang elegan:

Basic Fallback

import litellm
from litellm import completion

Konfigurasi fallback
litellm.setverbose = False


def completiondenganfallback(messages, modelchain=None):
    """Coba model secara berurutan sampai berhasil."""
    if modelchain is None:

        modelchain = [
            "gpt-4o",
            "anthropic/claude-sonnet-4-20250514",
            "gemini/gemini-2.0-flash"
        ]

    for model in modelchain:

        try:
            response = completion(
                model=model,
                messages=messages,
                timeout=30
            )
            print(f"Berhasil menggunakan model: {model}")
            return response
        except Exception as e:
            print(f"Model {model} gagal: {e}")
            continue

    raise Exception("Semua model dalam fallback chain gagal!")

Penggunaan
response = completiondenganfallback(

    messages=[{"role": "user", "content": "Halo!"}]
)
print(response.choices[0].message.content)

import litellm

Konfigurasi retry global
litellm.numretries = 3  # Coba ulang 3 kali
litellm.retryafter = 5  # Tunggu 5 detik antar retry


response = litellm.completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Halo!"}],
    numretries=3,
    timeout=30
)

Load Balancing

Load balancing memungkinkan Anda mendistribusikan request ke beberapa deployment model yang sama untuk meningkatkan throughput:

from litellm import Router

Konfigurasi router dengan beberapa deployment
modellist = [

    {
        "modelname": "gpt-4o",
        "litellmparams": {

            "model": "gpt-4o",
            "apikey": "sk-key-1",
        }
    },
    {
        "modelname": "gpt-4o",

        "litellmparams": {
            "model": "gpt-4o",
            "apikey": "sk-key-2",

        }
    },
    {
        "modelname": "gpt-4o",
        "litellmparams": {

            "model": "azure/gpt-4o",
            "apikey": "azure-key",
            "apibase": "https://your-resource.openai.azure.com",

            "apiversion": "2024-02-15-preview"
        }
    }
]

router = Router(
    modellist=modellist,
    routingstrategy="least-busy",  # Opsi: simple-shuffle, least-busy, latency-based-routing

    numretries=2
)

Router otomatis mendistribusikan request
response = router.completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Jelaskan load balancing."}]
)
print(response.choices[0].message.content)

Strategi routing yang tersedia:

• simple-shuffle: Distribusi acak
• least-busy: Kirim ke deployment yang paling sedikit antrian
• latency-based-routing: Kirim ke deployment dengan latensi terendah
• usage-based-routing: Distribusi berdasarkan penggunaan (TPM/RPM)

Cost Tracking dan Budgeting

LiteLLM menyediakan fitur pelacakan biaya bawaan yang sangat berguna:

Tracking Biaya per Request

import litellm
from litellm import completioncost


response = litellm.completion(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Tulis puisi tentang Python programming."}
    ]
)

Hitung biaya
cost = completioncost(completionresponse=response)

print(f"Biaya request ini: ${cost:.6f}")
print(f"Token input: {response.usage.prompttokens}")
print(f"Token output: {response.usage.completiontokens}")

print(f"Total token: {response.usage.totaltokens}")

Budget Tracking Kumulatif

import litellm

class BudgetTracker:
    """Tracker biaya kumulatif untuk mengontrol pengeluaran."""

    def init(self, budgetlimit: float = 10.0):

        self.totalcost = 0.0
        self.budgetlimit = budgetlimit
        self.requesthistory = []


    def trackedcompletion(self, model: str, messages: list, kwargs):

        if self.totalcost >= self.budgetlimit:
            raise Exception(
                f"Budget habis! Total: ${self.totalcost:.4f}, "

                f"Limit: ${self.budgetlimit:.2f}"
            )

        response = litellm.completion(
            model=model,
            messages=messages,
            kwargs
        )

        cost = litellm.completioncost(completionresponse=response)
        self.totalcost += cost

        self.requesthistory.append({
            "model": model,
            "cost": cost,
            "tokens": response.usage.totaltokens

        })

        print(f"Request cost: ${cost:.6f} | Total: ${self.totalcost:.6f} | "
              f"Remaining: ${self.budgetlimit - self.totalcost:.6f}")

        return response

    def getsummary(self):

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

        print(f"Budget Summary")
        print(f"{'='50}")
        print(f"Total requests: {len(self.requesthistory)}")
        print(f"Total cost: ${self.totalcost:.6f}")

        print(f"Budget limit: ${self.budgetlimit:.2f}")
        print(f"Remaining: ${self.budgetlimit - self.totalcost:.6f}")

Penggunaan
tracker = BudgetTracker(budgetlimit=5.0)


response = tracker.trackedcompletion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Halo!"}]
)

tracker.getsummary()

import litellm

OpenAI Embedding
response = litellm.embedding(
    model="text-embedding-3-small",
    input=["Machine learning adalah cabang dari AI",
           "Deep learning menggunakan neural network"]
)

embedding1 = response.data[0].embedding
embedding2 = response.data[1].embedding

print(f"Dimensi embedding: {len(embedding1)}")

Hitung cosine similarity
import numpy as np

def cosinesimilarity(a, b):

    return np.dot(a, b) / (np.linalg.norm(a)  np.linalg.norm(b))


similarity = cosinesimilarity(embedding1, embedding2)
print(f"Cosine similarity: {similarity:.4f}")

# Cohere Embedding
response = litellm.embedding(
    model="cohere/embed-english-v3.0",
    input=["Hello world", "Machine learning is great"]
)

Azure OpenAI Embedding
response = litellm.embedding(
    model="azure/text-embedding-3-small",
    input=["Hello world"],
    apikey="your-azure-key",

    apibase="https://your-resource.openai.azure.com",
    apiversion="2024-02-15-preview"

)

from litellm import Router
import asyncio

Konfigurasi production router
modellist = [
    # Primary: GPT-4o
    {
        "modelname": "primary-model",

        "litellmparams": {
            "model": "gpt-4o",
            "apikey": "sk-openai-key",

            "rpm": 100,  # Rate limit: 100 requests per minute
            "tpm": 100000  # Token limit: 100k tokens per minute
        }
    },
    # Fallback 1: Claude
    {
        "modelname": "fallback-model",
        "litellmparams": {

            "model": "anthropic/claude-sonnet-4-20250514",
            "apikey": "sk-ant-key",
            "rpm": 50
        }
    },
    # Fallback 2: Gemini
    {
        "modelname": "fallback-model-2",

        "litellmparams": {
            "model": "gemini/gemini-2.0-flash",
            "apikey": "gemini-key",

            "rpm": 60
        }
    }
]

router = Router(
    modellist=modellist,

    fallbacks=[
        {"primary-model": ["fallback-model", "fallback-model-2"]}
    ],
    routingstrategy="latency-based-routing",
    numretries=3,

    retryafter=5,
    timeout=30,
    allowedfails=2,  # Tandai deployment gagal setelah 2 kali error

    cooldowntime=60   # Cooldown 60 detik untuk deployment yang gagal
)

Synchronous call
response = router.completion(
    model="primary-model",
    messages=[{"role": "user", "content": "Halo!"}]
)

Async call untuk throughput tinggi
async def asynccompletion():

    response = await router.acompletion(
        model="primary-model",
        messages=[{"role": "user", "content": "Halo dari async!"}]
    )
    return response

Jalankan async
result = asyncio.run(asynccompletion())
print(result.choices[0].message.content)

import litellm
from litellm import Router
from datetime import datetime

class MultiProviderChatbot:
    """Chatbot produksi dengan multi-provider support dan fallback otomatis."""

    def init(self):
        modellist = [

            {
                "modelname": "smart-model",
                "litellmparams": {

                    "model": "gpt-4o",
                    "rpm": 100
                }
            },
            {
                "modelname": "smart-model",
                "litellmparams": {

                    "model": "anthropic/claude-sonnet-4-20250514",
                    "rpm": 50
                }
            },
            {
                "modelname": "fast-model",
                "litellmparams": {

                    "model": "gpt-4o-mini",
                    "rpm": 200
                }
            },
            {
                "modelname": "fast-model",
                "litellmparams": {

                    "model": "gemini/gemini-2.0-flash",
                    "rpm": 100
                }
            }
        ]

        self.router = Router(
            modellist=modellist,

            routingstrategy="latency-based-routing",
            numretries=2,

            timeout=30,
            allowedfails=2,
            cooldowntime=30

        )

        self.conversationhistory = []
        self.totalcost = 0.0

        self.totaltokens = 0

    def selectmodel(self, message: str) -> str:
        """Pilih model berdasarkan kompleksitas pesan."""
        complexkeywords = [

            "analisis", "jelaskan detail", "bandingkan",
            "tulis kode", "debug", "arsitektur"
        ]
        if any(kw in message.lower() for kw in complexkeywords):
            return "smart-model"
        return "fast-model"

    def chat(self, usermessage: str, usestreaming: bool = False) -> str:
        """Kirim pesan dan dapatkan respons."""
        self.conversationhistory.append({

            "role": "user",
            "content": usermessage
        })

        model = self.selectmodel(usermessage)

        systemmessage = {
            "role": "system",
            "content": (
                "Kamu adalah asisten AI yang ramah dan membantu. "
                "Jawab dalam bahasa yang sama dengan pertanyaan pengguna."
            )
        }
        messages = [systemmessage] + self.conversationhistory[-10:]

        try:
            if usestreaming:

                return self.streamresponse(model, messages)

            else:
                return self.normalresponse(model, messages)

        except Exception as e:
            errormsg = f"Maaf, terjadi error: {str(e)}"
            return errormsg


    def normalresponse(self, model: str, messages: list) -> str:

        """Respons normal (non-streaming)."""
        response = self.router.completion(
            model=model,
            messages=messages
        )

        assistantmessage = response.choices[0].message.content
        self.conversationhistory.append({

            "role": "assistant",
            "content": assistantmessage
        })

        cost = litellm.completioncost(completionresponse=response)
        self.totalcost += cost

        self.totaltokens += response.usage.totaltokens


        return assistantmessage

    def streamresponse(self, model: str, messages: list) -> str:
        """Respons streaming."""
        response = self.router.completion(
            model=model,
            messages=messages,
            stream=True
        )

        fullresponse = ""

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

        print()

        self.conversationhistory.append({

            "role": "assistant",
            "content": fullresponse
        })
        return fullresponse


    def getstats(self):
        """Tampilkan statistik penggunaan."""
        print(f"\n{'='50}")
        print(f"Statistik Chatbot")
        print(f"{'='50}")

        print(f"Total pesan: {len(self.conversationhistory)}")

        print(f"Total token: {self.totaltokens:,}")
        print(f"Total biaya: ${self.totalcost:.6f}")

        print(f"Rata-rata biaya/pesan: "
              f"${self.totalcost / max(len(self.conversationhistory), 1):.6f}")


    def reset(self):
        """Reset riwayat percakapan."""
        self.conversationhistory = []
        print("Riwayat percakapan direset.")


Jalankan chatbot
def main():
    chatbot = MultiProviderChatbot()
    print("Multi-Provider Chatbot (ketik 'quit' untuk keluar)")
    print("Ketik 'stats' untuk melihat statistik")
    print("Ketik 'stream' di awal pesan untuk streaming")
    print(f"{'='50}\n")

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


        if userinput.lower() == 'quit':
            chatbot.getstats()

            break
        elif userinput.lower() == 'stats':
            chatbot.getstats()

            continue
        elif userinput.lower() == 'reset':
            chatbot.reset()
            continue

        usestreaming = userinput.lower().startswith('stream ')
        if usestreaming:

            userinput = userinput[7:]


        print(f"\nAsisten: ", end="")
        if not usestreaming:
            response = chatbot.chat(userinput)

            print(response)
        else:
            chatbot.chat(userinput, use_streaming=True)
        print()

if name == "main":
    main()

Tips dan Best Practices

import litellm

litellm.cache = litellm.Cache(type="redis", host="localhost", port=6379)

Request yang sama akan menggunakan cache
response = litellm.completion(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Apa itu Python?"}],
    caching=True
)

Kesimpulan

LiteLLM adalah tool yang sangat powerful untuk bekerja dengan berbagai provider LLM. Dengan unified interface, proxy server, fallback mechanism, cost tracking, dan load balancing, LiteLLM menyederhanakan kompleksitas pengelolaan multi-provider LLM menjadi beberapa baris kode saja.

Mulailah dengan instalasi sederhana, coba beberapa provider, lalu implementasikan fitur-fitur production seperti Router dan Proxy Server sesuai kebutuhan Anda. Dengan LiteLLM, Anda mendapatkan fleksibilitas penuh untuk berpindah antar provider tanpa vendor lock-in.

Referensi dan sumber:

• Dokumentasi resmi LiteLLM: https://docs.litellm.ai/
• Repository GitHub: https://github.com/BerriAI/litellm
• Daftar model yang didukung: https://docs.litellm.ai/docs/providers