MIGRATIEGIDS

Van LiteLLM naar Wäg in een middag, niet een kwartaal

LiteLLM brengt teams snel naar multi-provider — daarom draait het in zoveel productiesystemen. Wat het niet meebrengt is een governancelaag: hiërarchische budgetten die uitgaven stoppen voordat de provider wordt aangeroepen, policy die in het request-pad wordt afgedwongen, toolaanroepen die wachten op een benoemde goedkeurder, en een auditvastlegging die u aan een complianceteam kunt geven. Wäg neemt de plaats in van de LiteLLM-proxy en voegt die laag toe. U behoudt uw SDK, uw modelaliassen en uw applicatiecode. U wijzigt één base-URL.

Wat verandert

  • De base-URL waar uw clients naar wijzen
  • Waar de configuratie staat
  • Het proxyproces dat u beheert

Wat niet

  • Uw SDK — openai, langchain, llamaindex, de LiteLLM-SDK als client, alles wat OpenAI-compatibel is
  • De modelaliassen waar uw code naar verwijst
  • Request- en responsevormen
  • Streaminggedrag, tool calling, vision
  • Uw provideraccounts en API-keys
HET PAD

Vier stappen, geen enkele een herbouw

1 · Importeer uw configuratie

Leest uw LiteLLM-config.yaml — op de commandline, of geplakt onder Platform → System → Import in de console — en produceert Wäg-configuratie: modellen en aliassen, verwijzingen naar provider-credentials, routingstrategie, fallbacks, Redis, projecten als applicaties met budgetten, virtuele keys, MCP-servers en A2A-agents.

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

Wat u moet controleren is het importrapport. Elke sleutel komt in een van vier lijsten terecht — mapped, skipped, needs_human en notes — en de commandline toont de aantallen met voorbeelden:

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

Illustratieve uitvoer. Het laat zien dat het rapport een echt artefact is: niets faalt stilzwijgend, alles zonder Wäg-equivalent wordt ter beoordeling vermeld in plaats van benaderd, en secrets worden nooit teruggegeven.

2 · Zet één base-URL om

Wäg bedient het OpenAI-compatibele oppervlak — /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 /v1/messages van Anthropic, /v1beta van Gemini, en /v1/mcp en /v1/a2a voor agents. LiteLLM-clients zoals Cline en Roo blijven werken: GET /model/info antwoordt met of zonder /v1, x-litellm-api-key wordt geaccepteerd op pass-through- en MCP-routes, en x-litellm-session-id groepeert calls tot gesprekken. Streaming is echte SSE.

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

Te controleren: GET /v1/models geeft uw aliassen terug, daarna één streaming- en één tool-calling-request per alias.

3 · Parallel verifiëren

Draai beide. Stuur een percentage van het verkeer naar Wäg, of spiegel er productieverkeer naartoe, en vergelijk. Omdat replica's stateless zijn en hun tellers via Redis en hun configuratie via Postgres delen, kunt u de canary op- en afschalen zonder budgetstatus te verliezen.

  • Routingbeslissingen — x-waeg-routed-model op elke response, x-waeg-route-reason bij intelligente routing
  • Cachegedrag — x-waeg-cache, en of de hitratio's overeenkomen met uw verwachtingen
  • Tokenaantallen en kostentoewijzing tegenover uw providerfactuur
  • p50/p95/p99-latentie, foutpercentages en fallbackpercentages
  • Compatibiliteitssignalen — request- en responsevelden waarop uw clients rekenen en die de gateway doorgaf of liet vallen, geteld uit uw eigen verkeer

4 · Omschakelen

Zet de base-URL om voor één service, daarna voor de rest. Laat de LiteLLM-deployment draaien tot u tevreden bent — terugrollen is dezelfde wijziging van één regel in omgekeerde richting.

Een verstandige volgorde: eerst interne tools, dan batch- en offline-workloads, dan één productieservice, dan alles.

Hoe u terugrolt

Zet de base-URL terug. Dat is de hele procedure — Wäg houdt geen status vast waar uw applicaties van afhangen, en uw provideraccounts, keys en modelaliassen blijven onaangeroerd. Laat beide deployments tijdens de overgang draaien. Er zit in deze migratie bewust geen lock-in-stap.

VELDMAPPING

Configuratieveld voor configuratieveld

LiteLLMWägOpmerkingen
model_list[].model_namemodelaliasWordt letterlijk overgenomen — uw code blijft werken
litellm_params.modeldeployment: provider + model_idMeerdere rijen met dezelfde model_name worden gewogen deployments van één alias
api_key: os.environ/Xapi_key_env: XBij runtime uit de omgeving gelezen; stap later over op een vault-verwijzing als u dat wilt
litellm_params.api_basebase_url van de providerEen andere host of regio wordt een extra provider
router_settings.routing_strategyrouting.strategysimple-shuffle en usage-based → weighted, least-busy en latency-based → latency, cost-based → cost; al het andere → weighted, met een notitie. Wäg voegt intelligent toe
litellm_settings.fallbacksalias-fallbacksBij de strategie intelligent sterkste-eerst geordend
litellm_settings.num_retriesrouting.max_retriesPlus een circuit breaker per deployment
general_settings.master_keymaster_keyEen os.environ-verwijzing wordt ter beoordeling vermeld: stel WAEG_MASTER_KEY in. Plus virtuele keys met budgetten en model-allowlists
projects[]: max_budget / budget_durationapplicatie + budgetWäg is hiërarchisch: org → team → gebruiker → applicatie → model → key
rpm op een deploymentdeploymentgewichtEen relatief gewicht, geen rate limit. De rpm_limit en tpm_limit van een project gaan naar de budgetpolicy van zijn applicatie; TPM per deployment heeft geen tegenhanger
cache_paramsna de import opnieuw aanleggenOnder Caching: exacte, canonieke, near-dup- en semantische tiers met bescherming tegen valse treffers
guardrailsna de import opnieuw aanleggenDezelfde leveranciers bestaan als catalogusitems, in een geordende keten: vóór, tijdens en na de call
success_callback / failure_callbackna de import opnieuw aanleggenOnder Observability: OTLP-, Langfuse- en HTTP-callbacks, plus Prometheus-metrics
custom Python callbacks— geen equivalentWäg is geen Python-proces. Gebruik in plaats daarvan een HTTP-webhook-policy-engine
keys[] met een project_idvirtuele keysGekoppeld aan de applicatie van het project, zodat het budget van een coding-agent aan zijn key hangt
mcp_serversplatform-MCP-serversBearer- en API-key-auth worden statische credentials; gebruikers-OAuth en token exchange vereisen Enterprise. Geïmporteerde tools worden vastgepind
agents[]platform-A2A-agentsVervers na de import elke agent card; de gateway haalt die op en controleert hem
import litellm (in-process)een client van de gatewayDe SDK blijft werken als hij naar Wäg wijst; zijn in-process routing en callbacks niet
EERLIJKE VERSCHILLEN

Inclusief wat LiteLLM kan en Wäg niet

Toets dit aan uw eigen opzet voordat u begint. Is een van de eerste twee punten dragend voor u, dan is de migratie een echt project in plaats van een middag — en dat kunt u beter nu weten dan halverwege.

Geen in-process routing

LiteLLM is als Python-bibliotheek te importeren. Wijst de SDK naar Wäg, dan blijft hij werken als client, maar zijn in-process routing en callbacks gaan niet mee — routing gebeurt in plaats daarvan in de gateway.

Geen eigen Python-callbacks

LiteLLM laat u willekeurige Python in de request-levenscyclus zetten. Het uitbreidingspunt van Wäg is een HTTP-webhook-policy-engine — schoner te beheren en te beveiligen, direct wel minder flexibel. Omvangrijke callback-logica wordt een kleine service.

Minder exotische providers, wel getrouwer

De providerdekking van LiteLLM is breder. Wäg heeft zo'n twaalf native providertypen, plus elke OpenAI-compatibele server, met native Anthropic- en Gemini-adapters die de getrouwheid van tools, vision en gestructureerde output bewaren in plaats van alles door één vorm te persen. Controleer eerst uw lijst.

Een andere routingfilosofie

Wäg scoort requests structureel — tools, vision, contextlengte, reasoning-signalen — naar harde capability-ondergrenzen, en kiest dan het goedkoopste model dat daaraan voldoet. Deterministisch en verklaarbaar via headers. Geen ML-router in het hot path.

Een andere cachefilosofie

Vier tiers — exact, canoniek, near-dup, semantisch — met bescherming tegen valse treffers. „Hoofdstad van Frankrijk” en „hoofdstad van Spanje” zijn een miss. Getallen, ontkenningen en gewijzigde entiteiten breken een hit.

Governance is hiërarchisch, niet vlak

Dit is de werkelijke reden om te migreren. De budgetten van LiteLLM gelden per key. Die van Wäg stapelen over org → team → gebruiker → applicatie → model → key met fair-share-plafonds, zodat het model aansluit op hoe organisaties werkelijk in elkaar zitten.

DAARNA

Wat u erbij hebt gewonnen

Budgetten die uitgaven vooraf stoppen

Gestapelde limieten over org → team → gebruiker → applicatie → model → key. Elk request wordt getoetst aan elke teller die van toepassing is; de eerste overschrijding wijst de call af vóórdat er providerkosten ontstaan. Met WAEG_CLUSTER=1 sluiten ze ook als Redis onbereikbaar is.

Policy in het request-pad

Een geordende scannerketen vóór de call, mid-stream op een schuivend venster, en na de call. PII, prompt injection, moderatie, of uw eigen webhook. Blokkeren, maskeren of redigeren per regel.

Bestuurde agent-loops

Externe MCP-servers krijgen credentials per server — statische key, doorgegeven gebruikerstoken of OAuth client credentials, en met Enterprise de eigen OAuth-koppeling van de gebruiker of token exchange — plus tool-allowlists en pinning. Toolaanroepen kunnen wachten op een benoemde goedkeurder, met Enterprise in Slack of Teams, en elke hop wordt gebudgetteerd en gelogd.

Een auditvastlegging

Elk request, elke routingbeslissing, elk policy-verdict en elke kostenpost in requestlogs, OTLP-traces en Prometheus-metrics — en, eenmaal ingeschakeld, een ondertekend, hash-geketend bewijsregister dat iedereen offline kan controleren met waeg ledger verify. Enterprise voegt bewijspakketten toe die aan de AI Act en DORA zijn gekoppeld, met gemarkeerde hiaten, en markering van AI-content.

Eén binary

Rust, distroless, non-root. Geen shell, interpreter of package manager in het gateway-image, ondertekende releases met een SBOM, en geen Node-runtime in de gateway — de optionele console-assistent draait als eigen service.

Een operator om het te draaien

Een first-party Kubernetes-operator declareert de gateway — topologie, opslag, OpenFGA, schaling via HPA of KEDA — en reconcilieert providers, modellen, budgetten, keys en guardrails als resources. Misconfiguraties verschijnen als conditions met een reden, niet als een pod die een uur later faalt.

Bekijk waar het gateway eindigt en de control plane begint · Bekijk de benchmarks

FAQ

Vragen die terugkomen

Moet ik mijn applicatiecode wijzigen?

Nee. U wijzigt de base-URL die uw OpenAI-compatibele client al gebruikt.

Gaat mijn LiteLLM-config mee?

Grotendeels, via waeg import litellm of Platform → System → Import in de console. U krijgt een rapport van wat is overgezet, wat is overgeslagen en wat een mens moet bekijken, en niets faalt stilzwijgend.

Kan ik beide tegelijk draaien?

Ja, en dat is de aanbevolen route. Spiegel of splits het verkeer en vergelijk routingbeslissingen, kosten en latentie voordat u omschakelt.

Is Wäg een fork van LiteLLM?

Nee. Het is een onafhankelijke implementatie in Rust, gebouwd rond een inference-request-model in plaats van dispatch via provider-SDK's. De compatibiliteit is bewust; de herkomst is een andere.

Wordt streaming ondersteund?

Ja — echte server-sent events, niet gebufferd en achteraf in stukken geknipt.

Tool calling en vision?

Ja, over de request-vormen van OpenAI, Anthropic en Gemini. Native adapters behouden providerspecifieke getrouwheid in plaats van terug te vallen op een kleinste gemene deler.

Hoe zit het met de native API's van Anthropic en Gemini?

Die worden ondersteund als first-class request-vormen, niet alleen als vertaling van de OpenAI-vorm.

Heb ik Redis nodig?

Voor meer dan één replica wel — het houdt budgetten en rate limits consistent over replica's heen, naast Postgres en OpenFGA die productie toch al nodig heeft. Embedded mode heeft niets externs nodig, maar is single-node en houdt zijn status in het geheugen.

Draait het op Kubernetes?

Ja, op twee manieren. Een first-party operator declareert de gateway en zijn catalogus als resources — stateless replica's, schaling via HPA of KEDA, gedeelde budgettellers, health- en readiness-probes — en er is een Helm-chart als u het liever zelf beheert.

Is het echt Apache-2.0?

Ja. Het productiepad van de gateway is Apache-2.0: routing, HA, caching, failover, budgetten, guardrails, MCP, jobs, observability en het bewijsregister. Enterprise voegt identiteit toe (SSO, SCIM, IdP-tokens), audit- en bewijspakketten, agentbetalingen, goedkeuringen in Slack en Teams, guardrails op pass-throughverkeer en support.

Belt het naar huis?

Nee. Geen telemetrie en geen analytics, en de licentie is een ondertekend offline token zonder licentieserver. Het draait volledig air-gapped: bekijk de uitgaande verbindingen en u ziet alleen de providers die u hebt geconfigureerd.

En als wij hulp nodig hebben bij de migratie?

Ontwerppartners krijgen praktische migratieondersteuning, ook vanaf LiteLLM — we doen het samen met u in plaats van u een handleiding te geven.

Één endpoint. Elk model. Volledige controle.

Begin met de open source

Draai het in uw eigen infrastructuur

Alles wat u nodig hebt om een control plane in productie te draaien staat onder Apache-2.0 en blijft dat ook — routing, HA, caching, failover, budgetten, policy, MCP, jobs en observability. Self-hosted, zonder account, zonder phone-home.

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

Geen werkende pull: de images zijn nog niet openbaar. Ontwerppartners krijgen de registrygegevens vertrouwelijk.

Implementeer in 5 minuten
Ontwerppartnerschap

Bepaal mee als design partner

Wäg is nog niet publiek beschikbaar. We werken met een kleine groep teams die multi-provider AI in productie draaien en governance en soevereiniteit serieus nemen, om de control plane te harden op echte workloads.

  • Alle Enterprise-functies inbegrepen, zonder licentiekosten
  • Migratie die we samen met u doen — ook vanaf LiteLLM
  • Een directe lijn naar de engineers die het bouwen, en echte invloed op wat er als volgende komt
Aanmelden voor het programma