LiteLLM Proxy: 1 API yli 100 LLM-mallille (15 min Docker-asennus)

LiteLLM Proxy: 1 API yli 100 LLM-mallille (15 min Docker-asennus)

Tiimisi jakaa OpenAI API -avaimia Slackin yksityisviesteissä. Kukaan ei tiedä, kuka käytti 400 dollaria viime tiistaina. Ei ole nopeusrajoituksia, ei varareittiä palveluntarjoajan kaatuessa, ja siirtyminen GPT-4o:sta Claudeen vaatii koodin muuttamista kahdessatoista eri paikassa. Kuulostaako tutulta? Itse isännöity LLM-yhdyskäytävä korjaa kaiken tämän, ja LiteLLM-proxy on suosituin avoimen lähdekoodin vaihtoehto: yksi OpenAI-yhteensopiva päätepiste, joka reitittää pyynnöt yli 100 LLM-palveluntarjoajalle.

Tämä opas kattaa koko litellm-proxyn asennuksen: Docker Compose PostgreSQL-tietokannalla, budjeteilla varustetut virtuaaliset tiimiavaimet, kustannusseuranta, nopeusrajoitukset sekä tekoäly-IDEiden kuten Claude Code ja Cursor yhdistäminen. Jos arvioit LLM-yhdyskäytäviä, tämä on käytännönläheinen opas, joka vie sinut nollasta tuotantoon.

Yksi tärkeä huomio ennen aloitusta: LiteLLM:n SDK (Python-kirjasto) ja Proxy-palvelin ovat eri asioita. SDK on tarkoitettu yksittäiselle kehittäjälle, joka kutsuu useita LLM-API:eja Pythonista. Proxy on tarkoitettu tiimeille; se toimii palvelimena sovellustesi ja LLM-palveluntarjoajien välillä. Jos olet yksin kehittävä skriptien kirjoittaja, SDK riittää. Jos hallinnoit avaimia, budjetteja ja käyttöoikeuksia tiimille, tarvitset proxyn. Sitä olemme nyt asentamassa.

LiteLLM Proxy pähkinänkuoressa

Näin asennustavat vertautuvat toisiinsa:

Useimmille tiimeille Docker Compose PostgreSQL:n kanssa on optimaalinen valinta. Rakennamme juuri sitä, mutta ensin saadaan proxy käyntiin 60 sekunnissa.

Esivalmistelut ja ympäristön asetukset

Varmista ennen aloitusta, että sinulla on:

• Docker ja Docker Compose asennettuna (Docker Desktop sisältää molemmat)
• Vähintään yksi LLM API -avain (OpenAI, Anthropic tai paikallinen Ollama-instanssi)
• Perustason tuntemus terminaalista / CLI:stä

Varmista, että Docker on valmis ja vie API-avaimet ympäristömuuttujiin:

# 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"

Siinä kaikki. Ei erikoisia Python-versioita, ei käyttöjärjestelmäkohtaisia työkaluja. Jos Docker toimii koneellasi, olet valmis.

Pika-aloitus: Ensimmäinen LiteLLM Proxy 60 sekunnissa

Yksi komento proxyn käynnistämiseen GPT-4o:n kanssa:

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

Testaa se curlilla:

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

Tai testaa Pythonilla:

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)

Mitä juuri tapahtui? Koodisi keskustelee osoitteen localhost:4000 kanssa käyttäen standardia OpenAI SDK -muotoa. Proxy vastaanottaa pyynnön, välittää sen OpenAI:n API:lle oikealla avaimella ja palauttaa vastauksen. Sovelluskoodisi ei koskaan näe varsinaista API-avainta.

Tässä on ydinajatus. Seuraavaksi rakennamme tuotantovalmiin asennuksen.

Tuotantovalmis Docker Compose -asennus PostgreSQL:llä

Yksittäinen docker run -komento toimii testaukseen, mutta tuotantotiimit tarvitsevat pysyvän kustannusseurannan, virtuaaliavaimet ja kunnollisen tietokantatallennuksen. Tämä tarkoittaa Docker Composea PostgreSQL:n kanssa.

Docker Compose -tiedosto

# 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 salaa virtuaaliavainten tiedot tietokannassa. LiteLLM:n tuotannon parhaat käytännöt suosittelevat tämän asettamista kaikille tiimiasennuksille.

Pinon käynnistäminen

# 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

Kaiken toiminnan varmistaminen

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

Jos näet onnistuneen vastauksen, tuotantopinosi on käynnissä. PostgreSQL tallentaa kaikki kustannustiedot, virtuaaliavaimet ja käyttömetriikat pysyvästi konttien uudelleenkäynnistysten yli.

Tuomio: Docker Compose + PostgreSQL on suositeltu tuotantoasennus. Saat pysyvän tallennustilan, kustannusseurannan ja virtuaaliavaimet noin 10 minuutin työllä. Docker-asennusdokumentaatio kattaa Kubernetesin ja Helmin, jos tarvitset myöhemmin automaattista skaalausta.

Config.yaml läpikäynti: Todellinen monipalveluntarjoajan asennus

Useimmat oppaat näyttävät config.yaml-tiedoston, jossa on vain yksi malli. Tässä näytämme, miltä todellinen tiimikonfiguraatio näyttää kolmella palveluntarjoajalla, varareiteillä ja kuormantasauksella.

Konfiguraatiotiedosto

# 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

Mallien aliakset ja reititys

Huomaa, että gpt-4o esiintyy konfiguraatiossa kahdesti: kerran osoittaen OpenAI:hun ja kerran Anthropiciin. Kun koodisi pyytää gpt-4o:a, LiteLLM kokeilee ensin OpenAI:a. Jos se epäonnistuu, fallbacks-asetus reitittää pyynnön automaattisesti Claudelle. Sovelluskoodiasi ei tarvitse muuttaa lainkaan.

Jos käytät tuotannon inferenssipalvelimia kuten vLLM:ää tai SGLangia, voit lisätä ne samalla tavalla asettamalla api_base-osoitteen inferenssipalvelimeesi.

Palveluntarjoajien pikaopas

Asetus routing_strategy: least-busy jakaa pyynnöt malleille, joilla on sama model_name. Jos sinulla on kaksi OpenAI-avainta (esim. eri organisaatioista eri nopeusrajoituksilla), listaa ne molemmat gpt-4o:n alle, ja LiteLLM tasaa kuormituksen.

Virtuaaliavaimet: Tiimikohtaiset API-avaimet budjeteilla ja nopeusrajoituksilla

Tässä kohtaa LiteLLM lakkaa olemasta "vain proxy" ja muuttuu tiiminhallintatyökaluksi. Virtuaaliavaimet позволяют antaa jokaiselle tiimin jäsenelle tai palvelulle oman API-avaimen kulurajoituksilla ja nopeuskatoilla, kaikki reititettynä yhden palveluntarjoajan API-avainsarjan kautta.

Tiimiavaimen luominen budjetilla

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

Vastaus antaa sinulle uuden avaimen, kuten sk-team-abc123.... Anna tämä frontend-tiimille. He voivat käyttää sitä täsmälleen kuten OpenAI-avainta, mutta se on rajoitettu 50 dollariin kuukaudessa ja sillä on pääsy vain määrittämiisi malleihin.

Nopeusrajoitusten asettaminen

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

Virtuaaliavainten dokumentaatio kattaa kaikki parametrit. Voit myös asettaa käyttäjäkohtaisia budjetteja ja nopeusrajoituksia vielä tarkempaan hallintaan.

Avainten käytön seuranta

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

Tarvitsetko peruuttaa vaarantuneen avaimen? Yksi API-kutsu:

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

Tuomio: Virtuaaliavaimet tekevät LiteLLM:stä tiimityökalun, eivät vain henkilökohtaisen proxyn. Ilman niitä lisäät vain yhden hyppelyn koodisi ja LLM:n väliin. Niiden kanssa saat käyttöoikeuksien hallinnan, budjettien valvonnan ja käytön kohdistamisen – asioita, jotka pitävät talouspäällikkösi rauhallisena.

Kustannusseuranta ja LiteLLM-hallintapaneeli

Kun PostgreSQL on yhdistetty, LiteLLM seuraa automaattisesti jokaisen pyynnön kustannuksia. Mitään ei tarvitse konfiguroida erikseen; se tuntee jokaisen tuetun mallin hintatiedot tokenia kohden.

Hallintapaneeli

Käytä sisäänrakennettua käyttöliittymää osoitteessa http://localhost:4000/ui (kirjaudu sisään master-avaimellasi). Näet:

• Kokonaiskulut kaikkien tiimien ja avainten osalta
• Mallikohtaisen erittelyn, mitkä mallit syövät budjettiasi
• Tiimikohtaiset kulut, kuka käyttää mitä
• Pyyntömäärän kehityksen ajassa

Tiimeille, jotka haluavat vakavasti vähentää LLM API -kuluja, pelkkä hallintapaneeli oikeuttaa proxyn käytön. Voit myös yhdistää LiteLLM:n ulkoisiin tekoälyn havainnointialustoihin kuten Langfuseen tai Heliconeen syvempää analytiikkaa varten.

Palveluntarjoajakohtainen kustannusvertailu

Tässä ovat suurimpien mallien hinnat miljoonaa tokenia kohden (huhtikuun 2026 tilanne):

Kun näet nämä luvut hallintapaneelissa tiimeittäin eriteltyinä, keskustelut "pitäisikö meidän käyttää halvempaa mallia tähän käyttötarkoitukseen?" muuttuvat hyvin konkreettisiksi.

Tuomio: Pelkkä kustannusseuranta oikeuttaa proxyn käytön mille tahansa tiimille, joka käyttää >100 $/kk LLM API:eihin. Et voi optimoida sitä, mitä et mittaa.

Tekoäly-IDEiden yhdistäminen: Claude Code, Cursor ja Continue

Tässä on asia, jonka useimmat LiteLLM-oppaat jättävät täysin huomiotta: voit ohjata tekoälykoodaustyökalusi myös proxyyn. Yksi proxy, kaikki IDE-työkalut, yhdistetty laskutus.

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

Siinä kaikki. Claude Code lähettää pyynnöt proxyllesi, joka reitittää ne Anthropicille (tai minne konfiguraatiosi määrää) samalla kun se seuraa kustannuksia virtuaaliavaimesi alla.

Cursor

Lisää Cursorin asetuksiin mukautettu OpenAI-yhteensopiva päätepiste:

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

Continue (VS Code)

Continuen config.json-tiedostossa:

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

Miksi vaivautua? Koska nyt jokaisen kehittäjän IDE-käyttö kulkee proxyn kautta. Saat henkilökohtaisen kustannusseurannan tekoälykoodiavustajille, nopeusrajoitukset, jotta kukaan ei polta vahingossa 500 dollaria koodaussession aikana, ja yhden paikan mallien vaihtamiseen, jos löydät paremman vaihtoehdon.

Yleisten ongelmien vianetsintä

"Config file not found" (Konfiguraatiotiedostoa ei löydy)

Tämä tarkoittaa yleensä, että volyymiliitoksen polku on väärä Dockerissa. Varmista, että config.yaml-tiedostosi on hakemistossa, josta liität:

# 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" PostgreSQL:ään

Docker-verkkoilu saa kaikki kiinni ainakin kerran. Jos LiteLLM ei tavoita Postgresia, tarkista:

• Että DATABASE_URL:n palvelunimi vastaa Docker Compose -palvelun nimeä (postgres, ei localhost)
• Että depends_on with condition: service_healthy on asetettu (jotta LiteLLM odottaa Postgresin olevan valmis)
• Että molemmat palvelut ovat samassa Docker-verkossa (ne ovat oletusarvoisesti Compossa)

"Invalid API key format" (Virheellinen API-avaimen muoto)

Yleisin sekaannus: LITELLM_MASTER_KEY on tarkoitettu ylläpitotoimintoihin (virtuaaliavainten luominen, hallintapaneelin käyttö). Virtuaaliavaimet (sk-team-...) ovat niitä, joita sovelluksesi käyttävät. Älä sekoita niitä.

"Model not found" (Mallia ei löydy)

Pyynnössäsi olevan model-kentän on vastattava config.yaml-tiedoston model_name:ä. Jos konfiguraatiosi määrittelee gpt-4o:n, mutta koodisi pyytää openai/gpt-4o:a, ne eivät täsmää. Tarkista tarkka kirjoitusasu.

Proxy käynnistyy, mutta pyynnöt jumittuvat

Yleensä kyse on palomuurista tai porttien sidonnasta. Varmista, että portti 4000 on eksponoitu eikä estetty:

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

Turvallisuus: Vältä versioita 1.82.7 ja 1.82.8

Maaliskuussa 2026 toimitusketjuhyökkäys vaikutti LiteLLM:n versioihin 1.82.7 ja 1.82.8. Kompromitoidut versiot poistettiin, ja puhdas julkaisu tuli version 1.83.0 myötä. Kiinnitä Docker-kuvasi aina tiettyyn versioon ja tarkista virallinen turvallisuuspäivitys ennen päivittämistä. Jos käytät versiota 1.82.7 tai 1.82.8, päivitä välittömästi.

Mikä LiteLLM-asennustapa kannattaa valita?

Jos luet tätä opasta ensimmäistä kertaa, aloita Docker Compose + PostgreSQL -asennuksella. Voit aina migratoida Kubernetesiin myöhemmin; config.yaml pysyy samana.

FAQ

Mikä on LiteLLM-proxy ja miten se toimii?

LiteLLM-proxy on avoimen lähdekoodin tekoäly-yhdyskäytäväpalvelin, joka sijaitsee sovellustesi ja LLM-palveluntarjoajien kuten OpenAI:n ja Anthropicin välissä. Se tarjoaa yhden OpenAI-yhteensopivan päätepisteen, joten koodisi keskustelee yhden URL-osoitteen kanssa, kun taas proxy hoitaa reitityksen, avaintenhallinnan, kustannusseurannan ja varareitit taustalla.

Miten asennan LiteLLM-proxyn Docker Composella?

Luo docker-compose.yml LiteLLM-proxy-kuvalla ja PostgreSQL-tietokannalla, liitä config.yaml-tiedostosi, aseta API-avaimet ympäristömuuttujiksi ja suorita docker compose up -d. Yllä olevassa Tuotantovalmis Docker Compose -osiossa on täydellinen, kopioi-liitä-valmis tiedosto.

Miten hallitsen tiimin API-avaimia LiteLLM:llä?

Käytä virtuaaliavaimia. Kutsu /key/generate-päätepistettä master-avaimellasi luodaksesi tiimi- tai käyttäjäkohtaisia avaimia. Jokaisella virtuaaliavaimella voi olla oma kuukausibudjetti, nopeusrajoitukset (RPM ja TPM) ja mallikohtaiset käyttörajoitukset. Virtuaaliavaimet-osio kattaa koko työnkulun.

Miten lisään kustannusseurannan ja nopeusrajoitukset LLM API:ni?

Yhdistä PostgreSQL proxyyn (DATABASE_URL:n kautta), ja kustannusseuranta tapahtuu automaattisesti. Aseta nopeusrajoituksia varten rpm_limit ja tpm_limit virtuaaliavaimia luodessasi. Sisäänrakennettu hallintapaneeli osoitteessa /ui näyttää tiimi- ja mallikohtaiset kulut.

Onko LiteLLM-proxy turvallinen käyttää tuotannossa?

Kyllä, yhtä varausta lukuun ottamatta: vältä versioita 1.82.7 ja 1.82.8, joihin vaikutti toimitusketjuhyökkäys maaliskuussa 2026. Käytä versiota 1.83.0 tai uudempaa. Kiinnitä Docker-kuvan versio, aseta LITELLM_SALT_KEY salausta varten ja noudata virallisia tuotannon parhaita käytäntöjä.

Mikä on ero LiteLLM SDK:n ja LiteLLM-proxyn välillä?

SDK on Python-kirjasto, jolla kutsutaan useita LLM-API:eja koodistasi. Proxy on itsenäinen palvelin, johon koko tiimisi yhdistyy. Käytä SDK:ta, kun olet yksinkehittäjä kirjoittamassa skriptiä. Käytä proxya, kun tarvitset jaettua käyttöoikeuksien hallintaa, kustannusseurantaa ja nopeusrajoituksia tiimin laajuisesti.

Voinko käyttää LiteLLM-proxya Ollaman ja paikallisten mallien kanssa?

Ehdottomasti. Lisää merkintä config.yaml-tiedostoosi muodossa model: ollama/llama3.1 ja api_base: http://host.docker.internal:11434 (tai Ollama-isäntäsi). Tiimisi voi sitten käyttää paikallisia malleja saman proxy-päätepisteen kautta, mikä on loistavaa kehitystä ja kulutonta testausta varten.

Paljonko LiteLLM-proxy maksaa?

LiteLLM-proxy on ilmainen ja avoimen lähdekoodin (MIT-lisenssi). Isännöit sitä omassa infrastruktuurissasi. Ainoat kulut ovat palvelimesi (pieni VPS riittää useimmille tiimeille) ja LLM API -kulut, jotka maksat jo nyt. BerriAI tarjoaa myös hallinnoitua pilviversiota, jos et halua isännöidä itse.

Mitä palveluntarjoajia LiteLLM tukee?

Yli 100, mukaan lukien OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, Google Vertex AI, Ollama, Hugging Face, Cohere, Replicate ja monet muut. Täydellinen lista löytyy LiteLLM GitHub-repositoriosta.

Miten päivitan LiteLLM-proxyn turvallisesti?

Kiinnitä aina tietty versio Docker-kuvan tagissa (esim. ghcr.io/berriai/litellm:v1.83.2-stable). Tarkista changelogista rikkoovat muutokset ennen päivittämistä. Älä koskaan käytä latest-tagia tuotannossa. Ja varmista aina, että uusi versio ei ole turvallisuusvaroituslistalla; maaliskuun 2026 tapaus osoitti, että jopa luotetut paketit voivat vaarantua.

Lopullinen tuomio ja seuraavat askeleet

Jos tiimisi käyttää rahaa LLM API:eihin eikä teillä ole vielä proxya, aloita Docker Compose + Postgres -asennuksella tänään. Asennus vie 15 minuuttia, ja sen lopussa sinulla on kulujen näkyvyys ja käyttöoikeuksien hallinta.

Kun järjestelmä on käynnissä, tutustu suojakaiteiden lisäämiseen LLM-putkeesi sisällön suodatusta ja turvallisuustarkastuksia varten. Proxy on perusta, kaikki muu rakentuu sen päälle.

Lähteet

• LiteLLM Proxy Pika-aloitus, Virallinen dokumentaatio
• LiteLLM Docker-asennusopas
• LiteLLM Virtuaaliavainten dokumentaatio
• LiteLLM Tuotannon parhaat käytännöt
• LiteLLM Turvallisuuspäivitys, Maaliskuu 2026
• BerriAI/litellm, GitHub-repositorio