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
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.yamlWat 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 → weightedIllustratieve 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.
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.
Configuratieveld voor configuratieveld
| LiteLLM | Wäg | Opmerkingen |
|---|---|---|
model_list[].model_name | modelalias | Wordt letterlijk overgenomen — uw code blijft werken |
litellm_params.model | deployment: provider + model_id | Meerdere rijen met dezelfde model_name worden gewogen deployments van één alias |
api_key: os.environ/X | api_key_env: X | Bij runtime uit de omgeving gelezen; stap later over op een vault-verwijzing als u dat wilt |
litellm_params.api_base | base_url van de provider | Een andere host of regio wordt een extra provider |
router_settings.routing_strategy | routing.strategy | simple-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.fallbacks | alias-fallbacks | Bij de strategie intelligent sterkste-eerst geordend |
litellm_settings.num_retries | routing.max_retries | Plus een circuit breaker per deployment |
general_settings.master_key | master_key | Een os.environ-verwijzing wordt ter beoordeling vermeld: stel WAEG_MASTER_KEY in. Plus virtuele keys met budgetten en model-allowlists |
projects[]: max_budget / budget_duration | applicatie + budget | Wäg is hiërarchisch: org → team → gebruiker → applicatie → model → key |
rpm op een deployment | deploymentgewicht | Een 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_params | na de import opnieuw aanleggen | Onder Caching: exacte, canonieke, near-dup- en semantische tiers met bescherming tegen valse treffers |
guardrails | na de import opnieuw aanleggen | Dezelfde leveranciers bestaan als catalogusitems, in een geordende keten: vóór, tijdens en na de call |
success_callback / failure_callback | na de import opnieuw aanleggen | Onder Observability: OTLP-, Langfuse- en HTTP-callbacks, plus Prometheus-metrics |
custom Python callbacks | — geen equivalent | Wäg is geen Python-proces. Gebruik in plaats daarvan een HTTP-webhook-policy-engine |
keys[] met een project_id | virtuele keys | Gekoppeld aan de applicatie van het project, zodat het budget van een coding-agent aan zijn key hangt |
mcp_servers | platform-MCP-servers | Bearer- en API-key-auth worden statische credentials; gebruikers-OAuth en token exchange vereisen Enterprise. Geïmporteerde tools worden vastgepind |
agents[] | platform-A2A-agents | Ververs na de import elke agent card; de gateway haalt die op en controleert hem |
import litellm (in-process) | een client van de gateway | De SDK blijft werken als hij naar Wäg wijst; zijn in-process routing en callbacks niet |
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.
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
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.
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 minutenBepaal 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