LiteLLM Proxy: 100'den Fazla LLM için 1 API (15 Dakikalık Docker Kurulumu)

LiteLLM Proxy Kurulumu: Anahtarlar, Maliyetler ve Hız Sınırları

Ekibiniz OpenAI API anahtarlarını Slack DM'lerde paylaşıyor. Geçen Salı kim 400 dolar harcadı, kimsenin haberi yok. Hız sınırlaması yok, bir sağlayıcı çöktüğünde yedek yok ve GPT-4o'dan Claude'a geçmek on iki yerde kod değişikliği gerektiriyor. Tanıdık geliyor mu? Kendi barındırdığınız bir LLM ağ geçidi bunların hepsini çözer; LiteLLM proxy ise en popüler açık kaynak seçeneğidir -- 100'den fazla LLM sağlayıcısına istekleri yönlendiren tek bir OpenAI uyumlu uç nokta.

Bu rehber tam LiteLLM proxy kurulumunu kapsamaktadır: PostgreSQL ile Docker Compose, bütçeli sanal ekip anahtarları, maliyet takibi, hız sınırları ve Claude Code ile Cursor gibi yapay zeka IDE'lerinin bağlanması. LLM ağ geçidi araçlarını değerlendiriyorsanız, bu sizi sıfırdan üretime götüren uygulamalı eğitimdir.

Başlamadan önce önemli bir not: LiteLLM SDK'sı (Python kütüphanesi) ve Proxy Sunucusu birbirinden farklı şeylerdir. SDK, Python'dan birden fazla LLM API'sini çağıran tek bir geliştirici içindir. Proxy ekipler içindir -- uygulamalarınız ile LLM sağlayıcıları arasında sunucu olarak oturur. Script yazan yalnız bir geliştiriciyseniz SDK yeterlidir. Bir ekip için anahtarları, bütçeleri ve erişimi yönetiyorsanız proxy'ye ihtiyacınız var. İşte burada kurduğumuz şey bu.

LiteLLM Proxy'ye Hızlı Bakış

Deployment yöntemlerinin karşılaştırması:

Çoğu ekip için PostgreSQL ile Docker Compose en uygun seçimdir. Bunu inşa edeceğiz -- ama önce bir proxy'yi 60 saniyede çalıştıralım.

Ön Gereksinimler ve Ortam Kurulumu

Başlamadan önce şunlara sahip olduğunuzdan emin olun:

• Docker ve Docker Compose kurulu (Docker Desktop ikisini de içerir)
• En az bir LLM API anahtarı (OpenAI, Anthropic veya yerel bir Ollama örneği)
• Temel terminal / CLI bilgisi

Docker'ın hazır olduğunu doğrulayın ve API anahtarlarınızı dışa aktarın:

# Docker'ın kurulu olduğunu kontrol edin
docker --version
docker compose version

# LLM API anahtarlarınızı dışa aktarın (kalıcılık için shell profilinize ekleyin)
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."

# İsteğe bağlı: proxy'niz için bir ana anahtar belirleyin (bunu daha sonra kullanacaksınız)
export LITELLM_MASTER_KEY="sk-master-gizli-anahtariniz"

Hepsi bu. Özel Python sürümü yok, işletim sistemine özgü araç yok. Docker makinenizde çalışıyorsa hazırsınız demektir.

Hızlı Başlangıç -- 60 Saniyede İlk LiteLLM Proxy'niz

GPT-4o ile bir proxy başlatmak için tek komut:

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

curl ile test edin:

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"}]
  }'

Veya Python'dan test edin:

from openai import OpenAI

# Standart OpenAI SDK'sını proxy'nize yönlendirin
client = OpenAI(
    api_key="sk-master-gizli-anahtariniz",
    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)

Ne oldu az önce? Kodunuz standart OpenAI SDK formatını kullanarak localhost:4000 ile konuşuyor. Proxy isteği alır, gerçek anahtarla OpenAI'nin API'sine iletir ve yanıtı döndürür. Uygulama kodunuz asıl API anahtarına hiç dokunmaz.

İşte temel fikir bu. Şimdi bir üretim kurulumu yapalım.

PostgreSQL ile Üretim Docker Compose Kurulumu

Tek docker run komutu test için işe yarar, ancak üretim ekipleri kalıcı maliyet takibi, sanal anahtarlar ve düzgün veritabanı depolaması gerektirir. Bu, PostgreSQL ile Docker Compose demektir.

Docker Compose Dosyası

# docker-compose.yml
version: "3.9"

services:
  litellm:
    image: ghcr.io/berriai/litellm:main-stable
    container_name: litellm-proxy
    ports:
      - "4000:4000"         # Proxy API portu
    volumes:
      - ./config.yaml:/app/config.yaml   # Yapılandırma dosyanızı bağlayın
    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, veritabanındaki sanal anahtar verilerini şifreler. LiteLLM üretim en iyi uygulamaları belgesi bunu her ekip deployment'ı için ayarlamanızı önerir.

Stack'i Başlatma

# Anahtarlarınızla bir .env dosyası oluşturun (bunu git'e commit etmeyin)
echo "LITELLM_MASTER_KEY=sk-master-gizlisiniz" > .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

# Her şeyi başlatın
docker compose up -d

# Logları kontrol edin
docker compose logs -f litellm

Her Şeyin Çalıştığını Doğrulama

# Sağlık kontrolü
curl http://localhost:4000/health

# Bir istek test edin
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"}]}'

Başarılı bir yanıt görüyorsanız, üretim stack'iniz çalışıyor. PostgreSQL tüm maliyet verilerini, sanal anahtarları ve kullanım metriklerini konteyner yeniden başlatmalarında kalıcı olarak depolar.

Sonuç: Docker Compose + PostgreSQL, önerilen üretim kurulumudur. Yaklaşık 10 dakikalık çalışmayla kalıcı depolama, maliyet takibi ve sanal anahtarlar sunar. Daha sonra otomatik ölçeklemeye ihtiyaç duyarsanız Docker deployment belgeleri Kubernetes ve Helm'i kapsamaktadır.

Config.yaml Açıklaması -- Gerçek Bir Çok Sağlayıcı Kurulumu

Çoğu eğitim tek modelli bir config.yaml gösterir. İşte üç sağlayıcı, fallback'ler ve yük dengeleme ile gerçek bir ekip yapılandırması şöyle görünür.

Yapılandırma Dosyası

# config.yaml -- Gerçek çok sağlayıcı kurulumu
model_list:
  # Birincil: OpenAI GPT-4o
  - model_name: gpt-4o          # KODUNUZUN kullandığı isim
    litellm_params:
      model: openai/gpt-4o      # Gerçek sağlayıcı/model
      api_key: os.environ/OPENAI_API_KEY

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

  # Yerel: Geliştirme / ücretsiz test için Ollama
  - model_name: local-llama
    litellm_params:
      model: ollama/llama3.1
      api_base: http://host.docker.internal:11434

  # Fallback: OpenAI çöktüğünde "gpt-4o"yu Claude'a yönlendir
  - 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    # Aynı adlı modeller arasında yük dengele
  num_retries: 3
  retry_after: 5                  # Yeniden denemeler arasındaki saniyeler
  fallbacks: [{"gpt-4o": ["claude-sonnet"]}]

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

Model Takma Adları ve Yönlendirme

gpt-4o'nun yapılandırmada iki kez göründüğüne dikkat edin -- biri OpenAI'ye, diğeri Anthropic'e işaret ediyor. Kodunuz gpt-4o istediğinde LiteLLM önce OpenAI'yi dener. Bu başarısız olursa fallbacks ayarı otomatik olarak Claude'a yönlendirir. Uygulama kodunuz hiç değişmez.

vLLM veya SGLang gibi üretim çıkarım backend'leri kullanıyorsanız, bunları aynı şekilde ekleyebilirsiniz -- sadece api_base'i çıkarım sunucunuza ayarlayın.

Sağlayıcı Hızlı Referans

routing_strategy: least-busy ayarı, istekleri aynı model_name'e sahip modeller arasında dağıtır. İki OpenAI anahtarınız varsa (belki farklı hız sınırlarına sahip farklı org'lar), her ikisini de gpt-4o altında listeleyin ve LiteLLM yükü dengeler.

Sanal Anahtarlar -- Bütçeli ve Hız Sınırlı Ekip API Anahtarları

LiteLLM'in "sadece bir proxy" olmaktan çıkıp ekip yönetim aracına dönüştüğü yer burasıdır. Sanal anahtarlar, her ekip üyesine veya servise harcama limitleri ve hız tavanlarıyla kendi API anahtarını vermenizi sağlar -- hepsi tek sağlayıcı API anahtarlarınız üzerinden yönlendirilir.

Bütçeli Ekip Anahtarı Oluşturma

# Aylık 50 $ bütçeyle sanal anahtar oluşturun
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"}
  }'

Yanıt size sk-team-abc123... gibi yeni bir anahtar verir. Bunu frontend ekibine verin. Bunu tam olarak bir OpenAI anahtarı gibi kullanabilirler, ancak aylık 50 $ ile sınırlıdır ve yalnızca belirttiğiniz modellere erişimi vardır.

Hız Sınırları Belirleme

# Hız sınırlı anahtar oluşturun: 100 istek/dakika, 50K token/dakika
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"]
  }'

Sanal anahtar belgeleri her parametreyi kapsar. Daha ayrıntılı kontrol için kullanıcı başına bütçe ve hız sınırları da ayarlayabilirsiniz.

Anahtar Kullanımını İzleme

import requests

# Bir anahtarın mevcut harcamasını ve limitlerini kontrol edin
response = requests.get(
    "http://localhost:4000/key/info",
    headers={"Authorization": f"Bearer {MASTER_KEY}"},
    params={"key": "sk-team-abc123..."}
)
info = response.json()
print(f"Harcanan: ${info['spend']:.2f} / ${info['max_budget']:.2f}")
print(f"Kullanılan RPM: {info['rpm_limit_used']} / {info['rpm_limit']}")

Ele geçirilmiş bir anahtarı iptal etmeniz mi gerekiyor? Tek bir API çağrısı:

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

Sonuç: Sanal anahtarlar LiteLLM'i kişisel bir proxy değil, bir ekip aracı yapar. Onlar olmadan sadece kodunuz ile LLM arasına bir atlama ekliyorsunuz. Onlarla birlikte erişim kontrolü, bütçe uygulaması ve kullanım atıfı var -- CFO'nuzun paniğe kapılmasını önleyen şeyler.

Maliyet Takibi ve LiteLLM Dashboard'u

PostgreSQL bağlandığında, LiteLLM her isteğin maliyetini otomatik olarak takip eder. Hiçbir şey yapılandırmanıza gerek yok -- desteklenen her model için token başına fiyatı bilir.

Dashboard

http://localhost:4000/ui adresindeki yerleşik arayüze erişin (ana anahtarınızla giriş yapın). Şunları göreceksiniz:

• Tüm ekipler ve anahtarlar genelinde toplam harcama
• Model bazında döküm -- hangi modeller bütçenizi tüketiyor
• Ekip bazında harcama -- kim ne kullanıyor
• İstek hacmi zaman içinde

LLM API maliyetlerini azaltma konusunda ciddi olan ekipler için dashboard tek başına proxy çalıştırmayı meşrulaştırır. Daha derin analizler için LiteLLM'i Langfuse veya Helicone gibi harici yapay zeka gözlemlenebilirlik platformlarına da bağlayabilirsiniz.

Sağlayıcı Bazında Maliyet Karşılaştırması

Nisan 2026 itibarıyla başlıca modellerin milyon token başına maliyeti:

Bu rakamları dashboard'da ekip bazında kırılmış olarak gördüğünüzde, "bu kullanım durumu için daha ucuz bir model kullanmalı mıyız?" konuşmaları çok somutlaşıyor.

Sonuç: Maliyet takibi tek başına, LLM API'lerine ayda 100 dolardan fazla harcayan her ekip için proxy'yi meşrulaştırır. Ölçemediğinizi optimize edemezsiniz.

Yapay Zeka IDE'lerini Bağlama -- Claude Code, Cursor ve Continue

Çoğu LiteLLM kılavuzunun tamamen atladığı bir şey: yapay zeka kodlama araçlarınızı da proxy'ye yönlendirebilirsiniz. Tek proxy, tüm IDE araçlarınız, birleşik faturalandırma.

Claude Code

# Claude Code'u LiteLLM proxy'nizi kullanacak şekilde ayarlayın
export ANTHROPIC_BASE_URL=http://localhost:4000/v1
export ANTHROPIC_API_KEY=sk-team-sanal-anahtariniz

Hepsi bu. Claude Code istekleri proxy'nize gönderir, proxy bunları Anthropic'e (veya yapılandırmanızın belirttiği yere) yönlendirirken maliyetleri sanal anahtarınız altında takip eder.

Cursor

Cursor'ın ayarlarında özel bir OpenAI uyumlu uç nokta ekleyin:

{
  "openai.apiBaseUrl": "http://localhost:4000/v1",
  "openai.apiKey": "sk-team-sanal-anahtariniz"
}

Continue (VS Code)

Continue'nun config.json'ında:

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

Neden zahmet edesiniz? Çünkü artık her geliştiricinin IDE kullanımı proxy üzerinden geçiyor. Yapay zeka kodlama asistanları için kişi başına maliyet takibi, kimsenin bir kodlama oturumunda kazara 500 dolar yakmaması için hız sınırları ve daha iyi bir seçenek bulduğunuzda modelleri değiştirmek için tek bir yer elde ediyorsunuz.

Yaygın Sorunların Giderilmesi

"Yapılandırma dosyası bulunamadı"

Bu genellikle Docker'daki volume bağlama yolunun yanlış olduğu anlamına gelir. config.yaml'ın bağladığınız dizinde olduğundan emin olun:

# Dosyanın düşündüğünüz yerde olduğunu kontrol edin
ls -la ./config.yaml

# docker-compose.yml'deki volume bağlaması eşleşmeli
# volumes:
#   - ./config.yaml:/app/config.yaml

PostgreSQL'e "Bağlantı Reddedildi"

Docker ağı herkesi en az bir kez yakalar. LiteLLM Postgres'e ulaşamıyorsa şunları kontrol edin:

• DATABASE_URL'deki servis adı Docker Compose servis adıyla eşleşiyor (postgres, localhost değil)
• condition: service_healthy ile depends_on ayarlanmış (LiteLLM'in Postgres hazır olana kadar beklemesi için)
• Her iki servis aynı Docker ağında (Compose'da varsayılan olarak öyledir)

"Geçersiz API Anahtarı Formatı"

En yaygın karışıklık: LITELLM_MASTER_KEY yönetici işlemleri içindir (sanal anahtarlar oluşturma, dashboard'a erişme). Sanal anahtarlar (sk-team-...) uygulamalarınızın kullandığı şeydir. Bunları karıştırmayın.

"Model Bulunamadı"

İsteklerinizdeki model alanı config.yaml'daki bir model_name ile eşleşmelidir. Yapılandırmanız gpt-4o tanımlıyor ancak kodunuz openai/gpt-4o istiyorsa eşleşmeyecektir. Tam yazımı kontrol edin.

Proxy başlıyor ama istekler takılıp kalıyor

Genellikle bir güvenlik duvarı veya port bağlama sorunu. 4000 portununun açık ve engellenmemiş olduğunu doğrulayın:

# Portun dinleyip dinlemediğini kontrol edin
docker port litellm-proxy
# Şunu göstermeli: 4000/tcp -> 0.0.0.0:4000

Güvenlik: 1.82.7 ve 1.82.8 Sürümlerinden Kaçının

Mart 2026'da bir tedarik zinciri olayı LiteLLM 1.82.7 ve 1.82.8 sürümlerini etkiledi. Ele geçirilen sürümler geri çekildi ve 1.83.0'da temiz bir sürüm yayınlandı. Docker görüntünüzü her zaman belirli bir sürüme sabitleyin ve yükseltmeden önce resmi güvenlik güncellemesini kontrol edin. 1.82.7 veya 1.82.8 kullanıyorsanız hemen güncelleyin.

Hangi LiteLLM Kurulum Yöntemini Seçmelisiniz?

Bu kılavuzu ilk kez okuyorsanız Docker Compose + PostgreSQL ile başlayın. Her zaman daha sonra Kubernetes'e geçebilirsiniz -- config.yaml aynı kalır.

SSS

LiteLLM proxy nedir ve nasıl çalışır?

LiteLLM proxy, uygulamalarınız ile OpenAI ve Anthropic gibi LLM sağlayıcıları arasında oturan bir açık kaynak yapay zeka ağ geçidi sunucusudur. Tek bir OpenAI uyumlu uç nokta sunar; böylece kodunuz bir URL ile konuşurken proxy arka planda yönlendirmeyi, anahtar yönetimini, maliyet takibini ve fallback'leri halleder.

LiteLLM proxy'yi Docker Compose ile nasıl kurarım?

LiteLLM proxy görüntüsü ve bir PostgreSQL veritabanıyla bir docker-compose.yml oluşturun, config.yaml'ınızı bağlayın, API anahtarlarınızı ortam değişkenleri olarak ayarlayın ve docker compose up -d çalıştırın. Yukarıdaki "Üretim Docker Compose Kurulumu" bölümünde kopyalamaya hazır eksiksiz bir dosya bulunmaktadır.

LiteLLM ile ekip API anahtarlarını nasıl yönetirim?

Sanal anahtarları kullanın. Ekip başına veya kullanıcı başına anahtarlar oluşturmak için ana anahtarınızla /key/generate uç noktasını çağırın. Her sanal anahtarın kendi aylık bütçesi, hız sınırları (RPM ve TPM) ve model erişim kısıtlamaları olabilir. "Sanal Anahtarlar" bölümü tam iş akışını kapsamaktadır.

LLM API'me maliyet takibi ve hız sınırları nasıl eklerim?

PostgreSQL'i proxy'ye bağlayın (DATABASE_URL aracılığıyla) ve maliyet takibi otomatik olarak gerçekleşir. Hız sınırları için sanal anahtarlar oluştururken rpm_limit ve tpm_limit ayarlayın. /ui adresindeki yerleşik dashboard ekip ve model başına harcamayı gösterir.

LiteLLM proxy üretimde kullanmak güvenli midir?

Evet, bir uyarıyla: Mart 2026'daki bir tedarik zinciri olayından etkilenen 1.82.7 ve 1.82.8 sürümlerinden kaçının. 1.83.0 veya sonraki sürümü kullanın. Docker görüntü sürümünüzü sabitleyin, şifreleme için LITELLM_SALT_KEY'i ayarlayın ve resmi üretim en iyi uygulamalarını izleyin.

LiteLLM SDK ile LiteLLM proxy arasındaki fark nedir?

SDK, kodunuzdan birden fazla LLM API'sini çağırmak için bir Python kütüphanesidir. Proxy, tüm ekibinizin bağlandığı bağımsız bir sunucudur. SDK'yı script yazan tek bir geliştirici olduğunuzda kullanın. Proxy'yi bir ekip genelinde paylaşılan erişim kontrolüne, maliyet takibine ve hız sınırlamaya ihtiyaç duyduğunuzda kullanın.

LiteLLM proxy'yi Ollama ve yerel modellerle kullanabilir miyim?

Kesinlikle. config.yaml'a model: ollama/llama3.1 ve api_base: http://host.docker.internal:11434 (veya Ollama hostnuzla) bir giriş ekleyin. Ekibiniz daha sonra aynı proxy uç noktası üzerinden yerel modellere erişebilir; bu da geliştirme ve ücretsiz test için harikadır.

LiteLLM proxy'nin maliyeti nedir?

LiteLLM proxy ücretsiz ve açık kaynaklıdır (MIT lisansı). Kendi altyapınızda kendiniz barındırırsınız. Tek maliyetler sunucunuz (çoğu ekip için küçük bir VPS yeterlidir) ve zaten ödediğiniz LLM API maliyetleridir. BerriAI, kendi barındırmak istemiyorsanız yönetilen bir bulut sürümü de sunmaktadır.

LiteLLM hangi sağlayıcıları destekler?

OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, Google Vertex AI, Ollama, Hugging Face, Cohere, Replicate ve çok daha fazlası dahil 100'den fazla sağlayıcı. Tam liste LiteLLM GitHub deposunda bulunmaktadır.

LiteLLM proxy'yi güvenli bir şekilde nasıl güncellerim?

Her zaman Docker görüntü etiketinizde belirli bir sürümü sabitleyin (örn. ghcr.io/berriai/litellm:v1.83.2-stable). Yükseltmeden önce kırıcı değişiklikler için değişiklik günlüğünü kontrol edin. Üretimde asla latest kullanmayın. Ve yeni sürümün güvenlik danışmanlık listesinde olmadığını her zaman doğrulayın -- Mart 2026 olayı, güvenilir paketlerin bile ele geçirilebileceğini kanıtladı.

Son Değerlendirme ve Sonraki Adımlar

Ekibiniz LLM API'lerine para harcıyor ve henüz bir proxy'niz yoksa bugün Docker Compose + Postgres ile başlayın. Kurulum 15 dakika sürer ve bunun sonunda maliyet görünürlüğüne ve erişim kontrolüne sahip olursunuz.

Çalışmaya başladıktan sonra içerik filtreleme ve güvenlik kontrolleri için LLM pipeline'ınıza guardrail eklemeyi keşfedin. Proxy temeli oluşturur -- diğer her şey bunun üzerine inşa edilir.

Kaynaklar

• LiteLLM Proxy Hızlı Başlangıç -- Resmi Belgeler
• LiteLLM Docker Deployment Kılavuzu
• LiteLLM Sanal Anahtarlar Belgesi
• LiteLLM Üretim En İyi Uygulamaları
• LiteLLM Güvenlik Güncellemesi -- Mart 2026
• BerriAI/litellm -- GitHub Deposu