MIGRERINGSGUIDE

Fra LiteLLM til Wäg på en eftermiddag, ikke et kvartal

LiteLLM får teams hurtigt op på flere providers — derfor kører så mange produktionsstakke det. Det, du ikke får, er et governance-lag: hierarkiske budgetter, der stopper forbruget, før provideren kaldes, politik håndhævet i request-stien, tool calls tilbageholdt til en navngiven godkender og et revisionsspor, du kan lægge på bordet hos et compliance-team. Wäg overtager LiteLLM-proxyens plads og tilføjer det lag. Du beholder dit SDK, dine modelaliasser og din applikationskode. Du ændrer én base-URL.

Hvad der ændrer sig

Den base-URL, dine klienter peger på
Hvor konfigurationen bor
Den proxy-proces, du driver

Hvad der ikke gør

Dit SDK — openai, langchain, llamaindex, LiteLLM-SDK'et som klient, alt OpenAI-kompatibelt
De modelaliasser, din kode refererer til
Request- og response-formater
Streaming-adfærd, tool calling, vision
Dine provider-konti og API-nøgler

VEJEN

Fire trin — ingen af dem en omskrivning

1 · Importér din konfiguration

Læser din LiteLLM config.yaml — på kommandolinjen eller indsat under Platform → System → Import i konsollen — og producerer Wäg-konfiguration: modeller og aliasser, referencer til provider-credentials, routing-strategi, fallbacks, Redis, projekter som applikationer med budgetter, virtuelle nøgler, MCP-servere og A2A-agenter.

$ waeg import litellm --from config.yaml -o waeg.yaml

$ waeg config validate --config waeg.yaml

Det, du skal se på, er importrapporten. Hver nøgle havner i en af fire lister — mapped, skipped, needs_human og notes — og kommandolinjen udskriver antallene med eksempler:

mapped
  model_list (12 rows)                    → 6 aliases: gpt-4o, claude, fast, cheap, embed, vision
  model_list[3].litellm_params.rpm: 600   → relative deployment weight
  litellm_settings.fallbacks              → alias fallbacks
  litellm_settings.num_retries: 3         → routing.max_retries: 3
  router_settings.routing_strategy        → routing.strategy: weighted (see notes)
  projects[0] (max_budget, budget_duration) → application app_ll_search + application budget
skipped
  litellm_settings.success_callback       → re-create under Observability
needs_human
  general_settings.master_key: os.environ/LITELLM_MASTER_KEY → set WAEG_MASTER_KEY
  litellm_settings.cache_params           → re-create under Caching
notes
  routing_strategy "latency-based-routing-v2" is not known → weighted

Illustrativt output. Pointen med at vise det er, at rapporten er et reelt artefakt: intet fejler i stilhed, alt uden en Wäg-ækvivalent listes til gennemgang frem for at blive tilnærmet, og hemmeligheder gentages aldrig i outputtet.

2 · Peg én base-URL

Wäg leverer den OpenAI-kompatible flade — /v1/chat/completions, /v1/responses (stateless), /v1/embeddings, /v1/images/*, /v1/audio/*, /v1/videos, /v1/rerank, /v1/ocr, /v1/moderations, /v1/files, /v1/batches, /v1/realtime, /v1/models — plus Anthropics /v1/messages, Geminis /v1beta samt /v1/mcp og /v1/a2a til agenter. LiteLLM-klienter som Cline og Roo virker fortsat: GET /model/info svarer med eller uden /v1, x-litellm-api-key accepteres på pass-through- og MCP-ruter, og x-litellm-session-id grupperer kald i samtaler. Streaming er ægte SSE.

  client = OpenAI(
-     base_url="http://litellm:4000/v1",
+     base_url="https://waeg.internal/v1",
      api_key=os.environ["GATEWAY_KEY"],
  )

Det, du skal tjekke: at GET /v1/models returnerer dine aliasser, og derefter én streaming-request og én tool-calling-request pr. alias.

3 · Verificér parallelt

Kør begge. Send en procentdel af trafikken til Wäg, eller shadow produktionstrafikken til den, og sammenlign. Fordi replicas er stateless og deler deres tællere via Redis og deres konfiguration via Postgres, kan du skalere din canary op og ned uden at miste budgettilstand.

Routing-beslutninger — x-waeg-routed-model på hvert svar, x-waeg-route-reason med intelligent routing
Cache-adfærd — x-waeg-cache, og om hit-raterne matcher dine forventninger
Token-tællinger og omkostningsattribuering holdt op mod din provider-faktura
p50 / p95 / p99-latens, fejlrater og fallback-rater
Kompatibilitetssignaler — request- og response-felter, dine klienter er afhængige af, som gatewayen videresendte eller droppede, talt i din egen trafik

4 · Skift over

Flyt base-URL'en for én service, derefter resten. Lad LiteLLM-deploymentet køre, indtil du er tilfreds — at rulle tilbage er den samme ændring på én linje i omvendt retning.

En fornuftig rækkefølge: interne værktøjer først, så batch- og offline-workloads, så én produktionsservice, så alt.

Sådan ruller du tilbage

Sæt base-URL'en tilbage. Det er hele proceduren — Wäg holder ingen tilstand, som dine applikationer afhænger af, og dine provider-konti, nøgler og modelaliasser er urørte. Lad begge deployments køre gennem overgangen. Der er ingen lock-in i denne migrering, og det er med vilje.

FELT-MAPPING

Konfigurationsfelt for konfigurationsfelt

LiteLLM	Wäg	Noter
`model_list[].model_name`	modelalias	Bevares ordret — din kode kører videre
`litellm_params.model`	deployment: provider + model_id	Flere rækker med samme model_name bliver til vægtede deployments af ét alias
`api_key: os.environ/X`	api_key_env: X	Læses fra miljøet ved runtime; skift senere til en vault-reference, hvis du foretrækker det
`litellm_params.api_base`	provider base_url	En anden host eller region bliver til en anden provider
`router_settings.routing_strategy`	routing.strategy	simple-shuffle og usage-based → weighted, least-busy og latency-based → latency, cost-based → cost; alt andet → weighted, med en note. Wäg tilføjer intelligent
`litellm_settings.fallbacks`	alias-fallbacks	Ordnet stærkeste-først i den intelligente strategi
`litellm_settings.num_retries`	routing.max_retries	Plus en circuit breaker pr. deployment
`general_settings.master_key`	master_key	En os.environ-reference listes til gennemgang: sæt WAEG_MASTER_KEY. Plus virtuelle nøgler med budgetter og model-allow-lists
`projects[]: max_budget / budget_duration`	applikation + budget	Wäg er hierarkisk: org → team → bruger → applikation → model → nøgle
`rpm på et deployment`	deployment-vægt	En relativ vægt, ikke en rate limit. Et projekts rpm_limit og tpm_limit går til applikationens budgetpolitik; TPM pr. deployment mappes ikke
`cache_params`	genskabes efter import	Under Caching: exact-, canonical-, near-dup- og semantic-niveauer med gates mod falske hits
`guardrails`	genskabes efter import	De samme leverandører findes som katalogelementer i en ordnet kæde: pre-call, mid-stream og post-call
`success_callback / failure_callback`	genskabes efter import	Under Observability: OTLP-, Langfuse- og HTTP-callbacks plus Prometheus-metrikker
`custom Python callbacks`	— ingen ækvivalent	Wäg er ikke en Python-proces. Brug i stedet en HTTP-webhook-policy-engine
`keys[] med et project_id`	virtuelle nøgler	Bundet til projektets applikation, så en kodeagents budget følger dens nøgle
`mcp_servers`	platformens MCP-servere	Bearer- og API-nøgle-auth bliver til statiske credentials; bruger-OAuth og token exchange kræver Enterprise. Importerede tools fastlåses
`agents[]`	platformens A2A-agenter	Opdatér hvert agent card efter importen; gatewayen henter og tjekker det
`import litellm (in-process)`	en klient af gatewayen	SDK'et virker fortsat, når det peger på Wäg; dets in-process-routing og callbacks gør ikke

ÆRLIGE FORSKELLE

Inklusive det, LiteLLM gør, som Wäg ikke gør

Hold dem op mod din opsætning, før du går i gang. Hvis en af de to første er bærende hos dig, er migreringen et rigtigt projekt frem for en eftermiddag — og det er bedre at vide nu end halvvejs inde.

Ingen in-process-routing

LiteLLM kan importeres som et Python-bibliotek. Peger SDK'et på Wäg, virker det fortsat som klient, men dets in-process-routing og callbacks følger ikke med — routing sker i stedet i gatewayen.

Ingen custom Python-callbacks

LiteLLM lader dig lægge vilkårlig Python ind i request-livscyklussen. Wägs udvidelsespunkt er en HTTP-webhook-policy-engine — nemmere at drive og sikre, mindre umiddelbart fleksibel. Tung callback-logik bliver til en lille service.

Færre eksotiske providers, mere trofaste

LiteLLMs provider-dækning er bredere. Wäg har omkring et dusin native provider-typer plus enhver OpenAI-kompatibel server, med native Anthropic- og Gemini-adaptere, der bevarer tro mod tools, vision og struktureret output frem for at presse alt gennem ét format. Tjek din liste først.

En anden routing-filosofi

Wäg scorer requests strukturelt — tools, vision, kontekstlængde, reasoning-signaler — til hårde kapabilitetsgulve og vælger så den billigste model, der klarer dem. Deterministisk og forklarligt i headers. Ingen ML-router i den varme sti.

En anden cache-filosofi

Fire niveauer — exact, canonical, near-dup, semantic — med gates mod falske hits. “Frankrigs hovedstad” og “Spaniens hovedstad” er et miss. Tal, negation og ændrede entiteter bryder et hit.

Governance er hierarkisk, ikke flad

Det er den egentlige grund til at migrere. LiteLLMs budgetter er pr. nøgle. Wägs stables på tværs af org → team → bruger → applikation → model → nøgle med fair-share-lofter, så modellen matcher, hvordan organisationer faktisk er skruet sammen.

BAGEFTER

Hvad du har vundet

Budgetter, der stopper forbruget først

Stablede grænser på tværs af org → team → bruger → applikation → model → nøgle. Hver request tjekkes mod hver tæller, der gælder; den første overskridelse afviser kaldet, før der bruges penge hos provideren. Med WAEG_CLUSTER=1 fejler de også lukket, hvis Redis ikke kan nås.

Politik i request-stien

En ordnet scannerkæde pre-call, mid-stream over et rullende vindue og post-call. PII, injection, moderation eller din egen webhook. Bloker, maskér eller redigér ud pr. regel.

Styrede agent-loops

Remote MCP-servere får credentials pr. server — statisk nøgle, videresendt brugertoken eller OAuth client credentials, og med Enterprise brugerens egen OAuth-forbindelse eller token exchange — plus tool-allow-lists og fastlåsning. Tool calls kan vente på en navngiven godkender, med Enterprise også i Slack eller Teams, og hvert hop er budgetteret og logget.

Et revisionsspor

Hver request, routing-beslutning, politikafgørelse og omkostning i request-logs, OTLP-traces og Prometheus-metrikker — og, når det er slået til, et signeret, hash-kædet bevisregister, som alle kan tjekke offline med waeg ledger verify. Enterprise tilføjer bevispakker knyttet til AI-forordningen og DORA, med mangler markeret, samt AI-indholdsmærkning.

Én binær

Rust, distroless, non-root. Ingen shell, fortolker eller pakkemanager i gateway-imaget, signerede releases med en SBOM og ingen Node-runtime i gatewayen — den valgfri konsolassistent kører som sin egen service.

En operator til at køre den

En førstepartsoperator til Kubernetes deklarerer gatewayen — topologi, storage, OpenFGA, HPA- eller KEDA-skalering — og rekonsilierer providers, modeller, budgetter, nøgler og guardrails som ressourcer. Fejlkonfigurationer viser sig som conditions med en begrundelse, ikke som en pod, der fejler en time senere.

Se hvor gatewayen slutter, og control plane begynder · Se benchmarks

FAQ

Spørgsmål der går igen

Skal jeg ændre min applikationskode?

Nej. Du ændrer den base-URL, din OpenAI-kompatible klient allerede bruger.

Kan min LiteLLM-config porteres?

Det meste, via waeg import litellm eller Platform → System → Import i konsollen. Du får en rapport over, hvad der blev mappet, hvad der blev sprunget over, og hvad der kræver et menneske — og intet fejler i stilhed.

Kan jeg køre begge på én gang?

Ja, og det er den anbefalede vej. Shadow eller split trafikken og sammenlign routing-beslutninger, omkostninger og latens, før du skifter over.

Er Wäg en fork af LiteLLM?

Nej. Det er en selvstændig implementering i Rust, bygget op om en inference-request-model frem for dispatch via provider-SDK'er. Kompatibiliteten er tilsigtet; ophavet er et andet.

Understøtter den streaming?

Ja — ægte server-sent events, ikke bufret og derefter chunked.

Tool calling og vision?

Ja, på tværs af OpenAI-, Anthropic- og Gemini-request-formater. Native adaptere bevarer provider-specifik tro mod formatet frem for at flade ud til en mindste fællesnævner.

Hvad med Anthropics og Geminis native API'er?

Understøttet som førsteklasses request-formater, ikke kun som oversættelser af OpenAI-formatet.

Har jeg brug for Redis?

Ved mere end én replica, ja — det holder budgetter og rate limits konsistente på tværs af replicas, ved siden af den Postgres og OpenFGA, som produktion alligevel kræver. Embedded-tilstand kræver intet eksternt, men er single-node og holder sin tilstand i hukommelsen.

Kører den på Kubernetes?

Ja, på to måder. En førstepartsoperator deklarerer gatewayen og dens katalog som ressourcer — tilstandsløse replikaer, HPA- eller KEDA-skalering, delte budgettællere, health- og readiness-probes — og der findes et Helm-chart, hvis du foretrækker selv at drive det.

Er den virkelig Apache-2.0?

Ja. Gatewayens produktionssti er Apache-2.0: routing, HA, caching, failover, budgetter, guardrails, MCP, jobs, observability og bevisregistret. Enterprise tilføjer identitet (SSO, SCIM, IdP-tokens), audit- og bevispakker, agentbetalinger, godkendelser i Slack og Teams, pass-through-guardrails og support.

Ringer den hjem?

Nej. Ingen telemetri og ingen analytics, og licensen er et signeret offline-token uden licensserver. Den kører fuldt air-gapped: overvåg dens udgående forbindelser, og du ser kun de providers, du har konfigureret.

Hvad hvis vi har brug for hjælp til migreringen?

Designpartnere får håndholdt migreringsstøtte, også fra LiteLLM — vi gør det sammen med jer i stedet for at udlevere en vejledning.

Ét endpoint. Alle modeller. Fuld kontrol.

Start med open source

Kør det i jeres egen infrastruktur

Alt, hvad I skal bruge for at drive en control plane i produktion, er Apache-2.0 og bliver ved med at være det — routing, HA, caching, failover, budgetter, policy, MCP, jobs og observability. Self-hosted, ingen konto, ingen phone-home.

$ docker run -p 4000:4000 <registry>/waeg-gateway:<version>

Endnu ikke et pull, der virker: images er ikke offentlige endnu. Designpartnere får registry-oplysningerne direkte.

Deploy på 5 minutter

GitHub Open source-løftet

Designpartnerskab

Vær med til at forme det som designpartner

Wäg er endnu ikke offentligt tilgængelig. Vi arbejder sammen med en lille gruppe teams, der kører multi-provider AI i produktion og tager governance og suverænitet alvorligt, for at hærde vores control plane på reelle workloads.

Alle Enterprise-funktioner inkluderet, uden licensomkostning
Praktisk migrering — vi gør det sammen med jer, også fra LiteLLM
Direkte adgang til de engineers, der bygger det, og reel indflydelse på, hvad der kommer næst

Ansøg om at deltage

Enterprise Trust center