LiteLLM Proxy: 1 API untuk 100+ LLM (Setup Docker 15 Menit)

LiteLLM Proxy: 1 API untuk 100+ LLM (Setup Docker 15 Menit)

Tim Anda berbagi kunci API OpenAI melalui DM Slack. Tidak ada yang tahu siapa yang menghabiskan $400 hari Selasa lalu. Tidak ada pembatasan laju, tidak ada fallback ketika penyedia layanan down, dan beralih dari GPT-4o ke Claude berarti mengubah kode di dua belas tempat berbeda. Terdengar familier? Sebuah gateway LLM self-hosted memperbaiki semua ini, dan proxy LiteLLM adalah opsi open-source paling populer, sebuah endpoint tunggal yang kompatibel dengan OpenAI yang merutekan permintaan ke 100+ penyedia LLM.

Panduan ini mencakup seluruh setup proxy litellm: Docker Compose dengan PostgreSQL, kunci tim virtual dengan anggaran, pelacakan biaya, batas laju, dan menghubungkan IDE AI seperti Claude Code dan Cursor. Jika Anda sedang mengevaluasi alat gateway LLM, ini adalah tutorial praktis yang membawa Anda dari nol hingga produksi.

Satu catatan penting sebelum kita mulai: SDK LiteLLM (library Python) dan Proxy Server adalah dua hal yang berbeda. SDK ditujukan untuk satu developer yang memanggil beberapa API LLM dari Python. Proxy ditujukan untuk tim, ia berfungsi sebagai server perantara antara aplikasi Anda dan penyedia LLM. Jika Anda seorang solo developer yang menulis skrip, SDK sudah cukup. Jika Anda mengelola kunci, anggaran, dan akses untuk sebuah tim, Anda memerlukan proxy. Itulah yang akan kita siapkan di sini.

Sekilas tentang LiteLLM Proxy

Berikut adalah perbandingan metode deployment:

Bagi sebagian besar tim, Docker Compose dengan PostgreSQL adalah titik tengah yang ideal. Itulah yang akan kita bangun, tetapi pertama-tama, mari jalankan proxy dalam 60 detik.

Prasyarat dan Setup Lingkungan

Sebelum memulai, pastikan Anda memiliki:

• Docker dan Docker Compose terinstal (Docker Desktop mencakup keduanya)
• Setidaknya satu kunci API LLM (OpenAI, Anthropic, atau instance Ollama lokal)
• Familiaritas dasar dengan terminal / CLI

Verifikasi Docker siap digunakan dan export kunci API Anda:

# Check Docker is installed
docker --version
docker compose version

# Export your LLM API keys (add to your shell profile for persistence)
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."

# Optional: set a master key for your proxy (you'll need this later)
export LITELLM_MASTER_KEY="sk-master-your-secret-key"

Itu saja. Tidak perlu versi Python khusus, tidak ada alat khusus OS. Jika Docker berjalan di mesin Anda, Anda siap.

Mulai Cepat, Proxy LiteLLM Pertama Anda dalam 60 Detik

Satu perintah untuk memulai proxy dengan GPT-4o:

docker run -d \
  --name litellm-proxy \
  -p 4000:4000 \
  -e OPENAI_API_KEY=$OPENAI_API_KEY \
  -e LITELLM_MASTER_KEY=$LITELLM_MASTER_KEY \
  ghcr.io/berriai/litellm:main-stable \
  --model openai/gpt-4o

Uji dengan curl:

curl http://localhost:4000/v1/chat/completions \
  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role": "user", "content": "Say hello from LiteLLM"}]
  }'

Atau uji dari Python:

from openai import OpenAI

# Point the standard OpenAI SDK at your proxy
client = OpenAI(
    api_key="sk-master-your-secret-key",
    base_url="http://localhost:4000/v1"
)

response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Say hello from LiteLLM"}]
)
print(response.choices[0].message.content)

Apa yang baru saja terjadi? Kode Anda berkomunikasi dengan localhost:4000 menggunakan format SDK OpenAI standar. Proxy menerima permintaan, meneruskannya ke API OpenAI dengan kunci asli, dan mengembalikan responsnya. Kode aplikasi Anda tidak pernah menyentuh kunci API yang sebenarnya.

Itulah ide intinya. Sekarang mari kita bangun setup produksi.

Setup Docker Compose Produksi dengan PostgreSQL

Perintah docker run tunggal berfungsi untuk pengujian, tetapi tim produksi membutuhkan pelacakan biaya yang persisten, kunci virtual, dan penyimpanan database yang tepat. Itu berarti Docker Compose dengan PostgreSQL.

File Docker Compose

# docker-compose.yml
version: "3.9"

services:
  litellm:
    image: ghcr.io/berriai/litellm:main-stable
    container_name: litellm-proxy
    ports:
      - "4000:4000"         # Proxy API port
    volumes:
      - ./config.yaml:/app/config.yaml   # Mount your config file
    environment:
      - LITELLM_MASTER_KEY=${LITELLM_MASTER_KEY}
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - DATABASE_URL=postgresql://litellm:litellm_password@postgres:5432/litellm
      - LITELLM_SALT_KEY=${LITELLM_SALT_KEY:-sk-salt-random-string}
    command: --config /app/config.yaml --detailed_debug
    depends_on:
      postgres:
        condition: service_healthy
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    container_name: litellm-db
    environment:
      POSTGRES_DB: litellm
      POSTGRES_USER: litellm
      POSTGRES_PASSWORD: litellm_password
    volumes:
      - litellm_pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U litellm"]
      interval: 5s
      timeout: 5s
      retries: 5
    restart: unless-stopped

volumes:
  litellm_pgdata:

LITELLM_SALT_KEY mengenkripsi data kunci virtual di database. Dokumentasi praktik terbaik produksi LiteLLM merekomendasikan pengaturan ini untuk setiap deployment tim.

Menjalankan Stack

# Create a .env file with your keys (don't commit this to git)
echo "LITELLM_MASTER_KEY=sk-master-your-secret" > .env
echo "OPENAI_API_KEY=sk-..." >> .env
echo "ANTHROPIC_API_KEY=sk-ant-..." >> .env
echo "LITELLM_SALT_KEY=sk-salt-$(openssl rand -hex 16)" >> .env

# Start everything
docker compose up -d

# Check logs
docker compose logs -f litellm

Memverifikasi Semuanya Berjalan

# Health check
curl http://localhost:4000/health

# Test a request
curl http://localhost:4000/v1/chat/completions \
  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "ping"}]}'

Jika Anda melihat respons sukses, stack produksi Anda sedang berjalan. PostgreSQL menyimpan semua data biaya, kunci virtual, dan metrik penggunaan secara persisten di seluruh restart container.

Kesimpulan: Docker Compose + PostgreSQL adalah setup produksi yang direkomendasikan. Ini memberi Anda penyimpanan persisten, pelacakan biaya, dan kunci virtual dengan sekitar 10 menit kerja. Dokumentasi deployment Docker mencakup Kubernetes dan Helm jika Anda memerlukan auto-scaling nanti.

Penjelasan Config.yaml, Setup Multi-Penyedia Nyata

Sebagian besar tutorial menampilkan config.yaml dengan satu model. Berikut adalah tampilan config tim nyata dengan tiga penyedia, fallback, dan load balancing.

File Konfigurasi

# config.yaml -- Real multi-provider setup
model_list:
  # Primary: OpenAI GPT-4o
  - model_name: gpt-4o          # The name YOUR code uses
    litellm_params:
      model: openai/gpt-4o      # The actual provider/model
      api_key: os.environ/OPENAI_API_KEY

  # Secondary: Anthropic Claude
  - model_name: claude-sonnet
    litellm_params:
      model: anthropic/claude-sonnet-4-20250514
      api_key: os.environ/ANTHROPIC_API_KEY

  # Local: Ollama for development / cost-free testing
  - model_name: local-llama
    litellm_params:
      model: ollama/llama3.1
      api_base: http://host.docker.internal:11434

  # Fallback: route "gpt-4o" to Claude if OpenAI is down
  - model_name: gpt-4o
    litellm_params:
      model: anthropic/claude-sonnet-4-20250514
      api_key: os.environ/ANTHROPIC_API_KEY

router_settings:
  routing_strategy: least-busy    # Load balance across same-name models
  num_retries: 3
  retry_after: 5                  # Seconds between retries
  fallbacks: [{"gpt-4o": ["claude-sonnet"]}]

general_settings:
  master_key: os.environ/LITELLM_MASTER_KEY
  database_url: os.environ/DATABASE_URL

Alias Model dan Routing

Perhatikan bahwa gpt-4o muncul dua kali dalam config, sekali mengarah ke OpenAI, sekali ke Anthropic. Ketika kode Anda meminta gpt-4o, LiteLLM mencoba OpenAI terlebih dahulu. Jika gagal, pengaturan fallbacks akan merutekan ke Claude secara otomatis. Kode aplikasi Anda tidak berubah sama sekali.

Jika Anda menggunakan backend inferensi produksi seperti vLLM atau SGLang, Anda dapat menambahkannya dengan cara yang sama, cukup setel api_base ke server inferensi Anda.

Referensi Cepat Penyedia

Pengaturan routing_strategy: least-busy mendistribusikan permintaan di seluruh model dengan model_name yang sama. Jika Anda memiliki dua kunci OpenAI (mungkin org berbeda dengan batas laju berbeda), daftar keduanya di bawah gpt-4o dan LiteLLM akan menyeimbangkan beban.

Kunci Virtual, Kunci API Per-Tim dengan Anggaran dan Batas Laju

Di sinilah LiteLLM berhenti menjadi "hanya proxy" dan menjadi alat manajemen tim. Kunci virtual memungkinkan Anda memberikan setiap anggota tim atau layanan kunci API mereka sendiri dengan batas pengeluaran dan batas laju, semuanya dirouting melalui satu set kunci API penyedia Anda.

Membuat Kunci Tim dengan Anggaran

# Create a virtual key with a $50/month budget
curl http://localhost:4000/key/generate \
  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "team_id": "frontend-team",
    "max_budget": 50.0,
    "budget_duration": "1mo",
    "models": ["gpt-4o", "claude-sonnet"],
    "metadata": {"purpose": "frontend AI features"}
  }'

Respons memberikan kunci baru seperti sk-team-abc123.... Berikan itu kepada tim frontend. Mereka dapat menggunakannya persis seperti kunci OpenAI, tetapi dibatasi hingga $50/bulan dan hanya memiliki akses ke model yang Anda tentukan.

Mengatur Batas Laju

# Create a key with rate limits: 100 requests/minute, 50K tokens/minute
curl http://localhost:4000/key/generate \
  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "team_id": "backend-team",
    "max_budget": 200.0,
    "budget_duration": "1mo",
    "rpm_limit": 100,
    "tpm_limit": 50000,
    "models": ["gpt-4o", "claude-sonnet", "local-llama"]
  }'

Dokumentasi kunci virtual mencakup setiap parameter. Anda juga dapat menetapkan anggaran dan batas laju per pengguna untuk kontrol yang lebih granular.

Memantau Penggunaan Kunci

import requests

# Check a key's current spend and limits
response = requests.get(
    "http://localhost:4000/key/info",
    headers={"Authorization": f"Bearer {MASTER_KEY}"},
    params={"key": "sk-team-abc123..."}
)
info = response.json()
print(f"Spent: ${info['spend']:.2f} / ${info['max_budget']:.2f}")
print(f"RPM used: {info['rpm_limit_used']} / {info['rpm_limit']}")

Perlu mencabut kunci yang terkompromi? Satu panggilan API:

curl -X POST http://localhost:4000/key/delete \
  -H "Authorization: Bearer $LITELLM_MASTER_KEY" \
  -H "Content-Type: application/json" \
  -d '{"keys": ["sk-team-abc123..."]}'

Kesimpulan: Kunci virtual adalah yang membuat LiteLLM menjadi alat tim, bukan hanya proxy pribadi. Tanpanya, Anda hanya menambahkan hop antara kode Anda dan LLM. Dengannya, Anda memiliki kontrol akses, penegakan anggaran, dan atribusi penggunaan, hal-hal yang menjaga CFO Anda dari kepanikan.

Pelacakan Biaya dan Dashboard LiteLLM

Setelah PostgreSQL terhubung, LiteLLM melacak biaya setiap permintaan secara otomatis. Anda tidak perlu mengonfigurasi apa pun, ia mengetahui harga per-token untuk setiap model yang didukung.

Dashboard

Akses UI bawaan di http://localhost:4000/ui (masuk dengan kunci master Anda). Anda akan melihat:

• Total pengeluaran di seluruh tim dan kunci
• Rincian per-model, model mana yang menggerogoti anggaran Anda
• Pengeluaran per-tim, siapa yang menggunakan apa
• Volume permintaan seiring waktu

Untuk tim yang serius tentang mengurangi biaya API LLM, dashboard saja sudah membenarkan menjalankan proxy. Anda juga dapat menghubungkan LiteLLM ke platform observabilitas AI eksternal seperti Langfuse atau Helicone untuk analitik yang lebih mendalam.

Perbandingan Biaya Per-Penyedia

Berikut adalah biaya model utama per juta token (per April 2026):

Ketika Anda melihat angka-angka ini di dashboard yang dipecah per tim, percakapan tentang "haruskah kita menggunakan model yang lebih murah untuk kasus penggunaan ini?" menjadi sangat konkret.

Kesimpulan: Pelacakan biaya saja sudah membenarkan proxy untuk tim mana pun yang menghabiskan >$100/bulan untuk API LLM. Anda tidak dapat mengoptimalkan apa yang tidak dapat Anda ukur.

Menghubungkan IDE AI, Claude Code, Cursor, dan Continue

Ini adalah sesuatu yang sebagian besar panduan LiteLLM lewatkan sepenuhnya: Anda dapat mengarahkan alat coding AI Anda ke proxy juga. Satu proxy, semua alat IDE Anda, penagihan terpusat.

Claude Code

# Set Claude Code to use your LiteLLM proxy
export ANTHROPIC_BASE_URL=http://localhost:4000/v1
export ANTHROPIC_API_KEY=sk-team-your-virtual-key

Itu saja. Claude Code mengirim permintaan ke proxy Anda, yang merutekannya ke Anthropic (atau ke mana pun config Anda mengarahkan) sambil melacak biaya di bawah kunci virtual Anda.

Cursor

Di pengaturan Cursor, tambahkan endpoint kompatibel OpenAI kustom:

{
  "openai.apiBaseUrl": "http://localhost:4000/v1",
  "openai.apiKey": "sk-team-your-virtual-key"
}

Continue (VS Code)

Di config.json Continue:

{
  "models": [
    {
      "title": "GPT-4o via LiteLLM",
      "provider": "openai",
      "model": "gpt-4o",
      "apiBase": "http://localhost:4000/v1",
      "apiKey": "sk-team-your-virtual-key"
    }
  ]
}

Mengapa repot-repot? Karena sekarang setiap penggunaan IDE developer melewati proxy. Anda mendapatkan pelacakan biaya per orang untuk asisten coding AI, batas laju sehingga tidak ada yang secara tidak sengaja membakar $500 dalam sesi coding, dan satu tempat untuk beralih model jika Anda menemukan opsi yang lebih baik.

Troubleshooting Masalah Umum

"Config file not found"

Ini biasanya berarti path volume mount salah di Docker. Pastikan config.yaml Anda berada di direktori yang Anda mount dari:

# Check the file exists where you think it does
ls -la ./config.yaml

# The volume mount in docker-compose.yml should match
# volumes:
#   - ./config.yaml:/app/config.yaml

"Connection refused" ke PostgreSQL

Jaringan Docker menjebak semua orang setidaknya sekali. Jika LiteLLM tidak dapat menjangkau Postgres, periksa bahwa:

• Nama layanan di DATABASE_URL cocok dengan nama layanan Docker Compose (postgres, bukan localhost)
• depends_on dengan condition: service_healthy diatur (sehingga LiteLLM menunggu Postgres siap)
• Kedua layanan berada di jaringan Docker yang sama (secara default di Compose)

"Invalid API key format"

Kebingungan paling umum: LITELLM_MASTER_KEY Anda adalah untuk operasi admin (membuat kunci virtual, mengakses dashboard). Kunci virtual (sk-team-...) adalah yang digunakan oleh aplikasi Anda. Jangan tertukar.

"Model not found"

Bidang model dalam permintaan Anda harus cocok dengan model_name di config.yaml. Jika config Anda mendefinisikan gpt-4o tetapi kode Anda meminta openai/gpt-4o, itu tidak akan cocok. Periksa ejaan yang tepat.

Proxy dimulai tetapi permintaan hang

Biasanya masalah firewall atau binding port. Verifikasi port 4000 terbuka dan tidak diblokir:

# Check if the port is listening
docker port litellm-proxy
# Should show: 4000/tcp -> 0.0.0.0:4000

Keamanan: Hindari Versi 1.82.7 dan 1.82.8

Pada Maret 2026, insiden rantai pasokan memengaruhi versi LiteLLM 1.82.7 dan 1.82.8. Versi yang dikompromikan telah ditarik, dan rilis bersih dikirimkan pada 1.83.0. Selalu pin image Docker Anda ke versi tertentu dan periksa update keamanan resmi sebelum melakukan upgrade. Jika Anda menggunakan 1.82.7 atau 1.82.8, update segera.

Metode Setup LiteLLM Mana yang Harus Anda Pilih?

Jika Anda membaca panduan ini untuk pertama kalinya, mulailah dengan Docker Compose + PostgreSQL. Anda selalu dapat bermigrasi ke Kubernetes nanti, config.yaml tetap sama.

FAQ

Apa itu proxy LiteLLM dan bagaimana cara kerjanya?

Proxy LiteLLM adalah server gateway AI open-source yang duduk di antara aplikasi Anda dan penyedia LLM seperti OpenAI dan Anthropic. Ia mengekspos satu endpoint yang kompatibel dengan OpenAI, sehingga kode Anda berbicara ke satu URL sementara proxy menangani routing, manajemen kunci, pelacakan biaya, dan fallback di belakang layar.

Bagaimana cara mengatur proxy LiteLLM dengan Docker Compose?

Buat docker-compose.yml dengan image proxy LiteLLM dan database PostgreSQL, mount config.yaml Anda, atur kunci API Anda sebagai variabel lingkungan, dan jalankan docker compose up -d. Bagian Production Docker Compose di atas memiliki file lengkap yang siap copy-paste.

Bagaimana cara mengelola kunci API tim dengan LiteLLM?

Gunakan kunci virtual. Hit endpoint /key/generate dengan kunci master Anda untuk membuat kunci per-tim atau per-pengguna. Setiap kunci virtual dapat memiliki anggaran bulanan sendiri, batas laju (RPM dan TPM), dan pembatasan akses model. Bagian Kunci Virtual mencakup alur kerja lengkapnya.

Bagaimana cara menambahkan pelacakan biaya dan batas laju ke API LLM saya?

Hubungkan PostgreSQL ke proxy (melalui DATABASE_URL), dan pelacakan biaya terjadi secara otomatis. Untuk batas laju, atur rpm_limit dan tpm_limit saat menghasilkan kunci virtual. Dashboard bawaan di /ui menunjukkan pengeluaran per-tim dan per-model.

Apakah proxy LiteLLM aman digunakan dalam produksi?

Ya, dengan satu catatan: hindari versi 1.82.7 dan 1.82.8, yang terpengaruh oleh insiden rantai pasokan pada Maret 2026. Gunakan versi 1.83.0 atau lebih baru. Pin versi image Docker Anda, atur LITELLM_SALT_KEY untuk enkripsi, dan ikuti praktik terbaik produksi resmi.

Apa perbedaan antara LiteLLM SDK dan proxy LiteLLM?

SDK adalah library Python untuk memanggil beberapa API LLM dari kode Anda. Proxy adalah server mandiri yang dihubungkan oleh seluruh tim Anda. Gunakan SDK ketika Anda adalah solo developer yang menulis skrip. Gunakan proxy ketika Anda memerlukan kontrol akses bersama, pelacakan biaya, dan pembatasan laju di seluruh tim.

Bisakah saya menggunakan proxy LiteLLM dengan Ollama dan model lokal?

Tentu saja. Tambahkan entri ke config.yaml Anda dengan model: ollama/llama3.1 dan api_base: http://host.docker.internal:11434 (atau host Ollama Anda). Tim Anda kemudian dapat mengakses model lokal melalui endpoint proxy yang sama, yang sangat bagus untuk pengembangan dan pengujian tanpa biaya.

Berapa biaya proxy LiteLLM?

Proxy LiteLLM gratis dan open-source (lisensi MIT). Anda meng-host sendiri di infrastruktur Anda sendiri. Satu-satunya biaya adalah server Anda (VPS kecil sudah cukup untuk sebagian besar tim) dan biaya API LLM yang sudah Anda bayar. BerriAI juga menawarkan versi cloud terkelola jika Anda tidak ingin meng-host sendiri.

Penyedia apa yang didukung LiteLLM?

Lebih dari 100, termasuk OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, Google Vertex AI, Ollama, Hugging Face, Cohere, Replicate, dan banyak lagi. Daftar lengkapnya ada di repositori GitHub LiteLLM.

Bagaimana cara memperbarui proxy LiteLLM dengan aman?

Selalu pin versi spesifik di tag image Docker Anda (misalnya, ghcr.io/berriai/litellm:v1.83.2-stable). Sebelum upgrade, periksa changelog untuk perubahan yang merusak. Jangan pernah menggunakan latest dalam produksi. Dan selalu verifikasi versi baru tidak ada dalam daftar advisori keamanan, insiden Maret 2026 membuktikan bahwa bahkan paket tepercaya pun dapat dikompromikan.

Kesimpulan Akhir dan Langkah Selanjutnya

Jika tim Anda mengeluarkan uang untuk API LLM dan Anda belum memiliki proxy, mulailah dengan Docker Compose + Postgres hari ini. Setup memakan waktu 15 menit, dan Anda akan memiliki visibilitas biaya serta kontrol akses pada akhirnya.

Setelah Anda berjalan, jelajahi menambahkan guardrails ke pipeline LLM Anda untuk filtering konten dan pemeriksaan keamanan. Proxy adalah fondasinya, segala sesuatu lainnya dibangun di atasnya.

Sumber

• Mulai Cepat Proxy LiteLLM, Dokumen Resmi
• Panduan Deployment Docker LiteLLM
• Dokumentasi Kunci Virtual LiteLLM
• Praktik Terbaik Produksi LiteLLM
• Update Keamanan LiteLLM, Maret 2026
• BerriAI/litellm, Repositori GitHub