Från LiteLLM till Wäg på en eftermiddag, inte ett kvartal
LiteLLM tar team till flera leverantörer snabbt — det är därför så många produktionsstackar kör den. Vad den inte ger er är ett styrningslager: hierarkiska budgetar som stoppar kostnaden innan leverantören anropas, policy som tillämpas i requestvägen, verktygsanrop som hålls kvar för en namngiven godkännare, och ett revisionsspår ni kan lämna till ett efterlevnadsteam. Wäg ersätter LiteLLM-proxyn och lägger till det lagret. Ni behåller ert SDK, era modellalias och er applikationskod. Ni byter en bas-URL.
Vad som förändras
- Bas-URL:en era klienter pekar på
- Var konfigurationen bor
- Proxyprocessen ni driftar
Vad som inte gör det
- Ert SDK — openai, langchain, llamaindex, LiteLLM-SDK:t som klient, allt OpenAI-kompatibelt
- Modellaliasen er kod refererar till
- Request- och svarsformer
- Streamingbeteende, verktygsanrop, vision
- Era leverantörskonton och API-nycklar
Fyra steg, inget av dem en omskrivning
1 · Importera er konfiguration
Läser er LiteLLM-config.yaml — på kommandoraden, eller inklistrad under Platform → System → Import i konsolen — och producerar Wäg-konfiguration: modeller och alias, referenser till leverantörsnycklar, routingstrategi, fallbacks, Redis, projekt som applikationer med budgetar, virtuella nycklar, MCP-servrar och A2A-agenter.
$ waeg import litellm --from config.yaml -o waeg.yaml$ waeg config validate --config waeg.yamlDet ni ska granska är importrapporten. Varje nyckel hamnar i en av fyra listor — mapped, skipped, needs_human och notes — och kommandoraden skriver ut antalen med exempel:
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 → weightedIllustrativ utdata. Poängen med att visa den är att rapporten är en verklig artefakt: ingenting misslyckas i tysthet, allt utan motsvarighet i Wäg listas för granskning i stället för att approximeras, och hemligheter skrivs aldrig ut.
2 · Peka om en bas-URL
Wäg exponerar den OpenAI-kompatibla ytan — /v1/chat/completions, /v1/responses (tillståndslös), /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 och /v1/a2a för agenter. LiteLLM-klienter som Cline och Roo fortsätter att fungera: GET /model/info svarar med eller utan /v1, x-litellm-api-key accepteras på pass-through- och MCP-rutter, och x-litellm-session-id grupperar anrop i konversationer. Streaming är äkta SSE.
client = OpenAI(
- base_url="http://litellm:4000/v1",
+ base_url="https://waeg.internal/v1",
api_key=os.environ["GATEWAY_KEY"],
)Det ni ska kontrollera: att GET /v1/models returnerar era alias, och sedan en streaming-request och en request med verktygsanrop per alias.
3 · Verifiera parallellt
Kör båda. Skicka en andel av trafiken till Wäg, eller skugga produktionstrafiken dit, och jämför. Eftersom replikerna är tillståndslösa och delar sina räknare via Redis och sin konfiguration via Postgres kan ni skala kanariefågeln upp och ner utan att tappa budgettillstånd.
- Routingbeslut — x-waeg-routed-model på varje svar, x-waeg-route-reason med intelligent routing
- Cachebeteende — x-waeg-cache, och om träffgraden motsvarar era förväntningar
- Antal tokens och kostnadsattribution mot er leverantörsfaktura
- Latens p50 / p95 / p99, felfrekvens och fallback-frekvens
- Kompatibilitetssignaler — fält i request och svar som era klienter förlitar sig på och som gatewayen vidarebefordrade eller släppte, räknade ur er egen trafik
4 · Växla över
Flytta bas-URL:en för en tjänst, sedan resten. Låt LiteLLM-installationen vara igång tills ni är nöjda — att rulla tillbaka är samma enradsändring i omvänd riktning.
En rimlig ordning: interna verktyg först, sedan batch- och offlinearbetslaster, sedan en produktionstjänst, sedan allt.
Ändra tillbaka bas-URL:en. Det är hela proceduren — Wäg håller inget tillstånd som era applikationer är beroende av, och era leverantörskonton, nycklar och modellalias är orörda. Låt båda installationerna vara igång genom övergången. Det finns inget inlåsningssteg i den här migreringen, medvetet.
Konfigurationsfält för konfigurationsfält
| LiteLLM | Wäg | Noteringar |
|---|---|---|
model_list[].model_name | modellalias | Bevaras ordagrant — er kod fortsätter fungera |
litellm_params.model | deployment: leverantör + model_id | Flera rader med samma model_name blir viktade deployments av ett och samma alias |
api_key: os.environ/X | api_key_env: X | Läses från miljön vid körning; byt till en valvreferens senare om ni föredrar det |
litellm_params.api_base | leverantörens base_url | En annan värd eller region blir en annan leverantör |
router_settings.routing_strategy | routing.strategy | simple-shuffle och usage-based → weighted, least-busy och latency-based → latency, cost-based → cost; allt annat → weighted, med en notering. Wäg lägger till intelligent |
litellm_settings.fallbacks | fallbacks för alias | Ordnade starkast först i den intelligenta strategin |
litellm_settings.num_retries | routing.max_retries | Plus en circuit breaker per deployment |
general_settings.master_key | master_key | En os.environ-referens listas för granskning: sätt WAEG_MASTER_KEY. Plus virtuella nycklar med budgetar och tillåtlistor för modeller |
projects[]: max_budget / budget_duration | applikation + budget | Wäg är hierarkisk: org → team → användare → applikation → modell → nyckel |
rpm på en deployment | deploymentvikt | En relativ vikt, inte en frekvensgräns. Ett projekts rpm_limit och tpm_limit går till applikationens budgetpolicy; TPM per deployment har ingen motsvarighet |
cache_params | återskapa efter importen | Under Caching: exakt, kanonisk, nära-dubblett och semantisk nivå med spärrar mot falska träffar |
guardrails | återskapa efter importen | Samma leverantörer finns som katalogobjekt, i en ordnad kedja: före anropet, mitt i strömmen och efter anropet |
success_callback / failure_callback | återskapa efter importen | Under Observability: OTLP-, Langfuse- och HTTP-callbacks, plus Prometheus-mätvärden |
custom Python callbacks | — ingen motsvarighet | Wäg är ingen Python-process. Använd en policymotor via HTTP-webhook i stället |
keys[] med ett project_id | virtuella nycklar | Bundna till projektets applikation, så att en kodagents budget följer med dess nyckel |
mcp_servers | MCP-servrar på plattformsnivå | Bearer- och API-nyckelautentisering blir statiska uppgifter; användar-OAuth och tokenutbyte kräver Enterprise. Importerade verktyg fästs |
agents[] | A2A-agenter på plattformsnivå | Uppdatera varje agents agent card efter importen; gatewayen hämtar och kontrollerar det |
import litellm (in-process) | en klient till gatewayen | SDK:t fortsätter att fungera när det pekar på Wäg; dess routing i processen och callbacks gör det inte |
Inklusive det LiteLLM gör som Wäg inte gör
Stäm av de här mot er uppsättning innan ni börjar. Om något av de två första är bärande för er är migreringen ett riktigt projekt snarare än en eftermiddag, och det bör ni veta nu i stället för halvvägs in.
Ingen routing i processen
LiteLLM kan importeras som ett Python-bibliotek. Pekat mot Wäg fortsätter SDK:t att fungera som klient, men dess routing i processen och callbacks följer inte med — routingen sker i gatewayen i stället.
Inga egna Python-callbacks
LiteLLM låter er släppa in godtycklig Python i requestlivscykeln. Wägs utbyggnadspunkt är en policymotor via HTTP-webhook — enklare att drifta och säkra, mindre omedelbart flexibel. Tung callback-logik blir en liten tjänst.
Färre exotiska leverantörer, mer trogna
LiteLLM täcker fler leverantörer. Wäg har ungefär ett dussin nativa leverantörstyper, plus alla OpenAI-kompatibla servrar, med nativa adaptrar för Anthropic och Gemini som bevarar troheten i verktygsanrop, vision och strukturerad utdata i stället för att platta till allt genom en och samma form. Kontrollera er lista först.
En annan routingfilosofi
Wäg poängsätter requests strukturellt — verktyg, vision, kontextlängd, signaler om resonemang — till hårda kapabilitetsgolv, och väljer sedan den billigaste modell som klarar dem. Deterministiskt och förklarbart i svarshuvuden. Ingen ML-router i hot path.
En annan cachefilosofi
Fyra nivåer — exakt, kanonisk, nära-dubblett, semantisk — med spärrar mot falska träffar. ”Frankrikes huvudstad” och ”Spaniens huvudstad” är en miss. Siffror, negationer och ändrade entiteter bryter en träff.
Styrningen är hierarkisk, inte platt
Det här är det egentliga skälet att migrera. LiteLLMs budgetar är per nyckel. Wägs staplas över org → team → användare → applikation → modell → nyckel med tak för rättvis andel, så att modellen matchar hur organisationer faktiskt ser ut.
Vad ni vann
Budgetar som stoppar kostnaden först
Staplade gränser över org → team → användare → applikation → modell → nyckel. Varje request kontrolleras mot varje räknare som gäller; första överträdelsen avvisar anropet innan någon kostnad uppstår hos leverantören. Med WAEG_CLUSTER=1 nekar de också om Redis inte går att nå.
Policy i requestvägen
En ordnad skannerkedja före anropet, mitt i strömmen på ett rullande fönster, och efter anropet. PII, injektion, moderering eller er egen webhook. Blockera, maskera eller redigera per regel.
Styrda agentloopar
Externa MCP-servrar får uppgifter per server — statisk nyckel, vidarebefordrad användartoken eller OAuth-klientuppgifter, och med Enterprise användarens egen OAuth-anslutning eller tokenutbyte — plus tillåtlistor och fästning av verktyg. Verktygsanrop kan vänta på en namngiven godkännare, i Slack eller Teams med Enterprise, och varje steg budgeteras och loggas.
Ett revisionsspår
Varje request, routingbeslut, policyutfall och kostnad i requestloggar, OTLP-spår och Prometheus-mätvärden — och, när den slagits på, en signerad, hashkedjad bevisliggare som vem som helst kan kontrollera offline med waeg ledger verify. Enterprise lägger till bevispaket mappade mot AI-förordningen och DORA, med luckor flaggade, och märkning av AI-innehåll.
En binär
Rust, distroless, utan root. Inget skal, ingen interpretator och ingen pakethanterare i gatewayens avbild, signerade releaser med SBOM, och ingen Node-runtime i gatewayen — den valfria konsolassistenten körs som en egen tjänst.
En operator som kör den
En egen Kubernetes-operator deklarerar gatewayen — topologi, lagring, OpenFGA, skalning med HPA eller KEDA — och stämmer av leverantörer, modeller, budgetar, nycklar och guardrails som resurser. Felkonfigurationer syns som villkor med en orsak, inte som en pod som fallerar en timme senare.
Se var gatewayen slutar och control plane:n börjar · Se benchmarks
Frågor som brukar dyka upp
Måste jag ändra min applikationskod?
Nej. Du ändrar bas-URL:en som din OpenAI-kompatibla klient redan använder.
Följer min LiteLLM-konfiguration med?
Det mesta, via waeg import litellm eller Platform → System → Import i konsolen. Ni får en rapport över vad som mappades, vad som hoppades över och vad som behöver en människa, och ingenting misslyckas i tysthet.
Kan jag köra båda samtidigt?
Ja, och det är den rekommenderade vägen. Skugga eller dela trafiken och jämför routingbeslut, kostnad och latens innan du växlar över.
Är Wäg en fork av LiteLLM?
Nej. Det är en oberoende implementation i Rust, byggd kring en inferensrequest-modell snarare än kring dispatch till leverantörs-SDK:er. Kompatibiliteten är medveten; ursprunget är ett annat.
Stöds streaming?
Ja — äkta server-sent events, inte buffrat och sedan uppdelat i bitar.
Verktygsanrop och vision?
Ja, över request-formerna från OpenAI, Anthropic och Gemini. Nativa adaptrar bevarar leverantörsspecifik trohet i stället för att platta till till en minsta gemensam nämnare.
Hur är det med Anthropics och Geminis nativa API:er?
De stöds som förstklassiga request-former, inte bara som översättningar av OpenAI-formen.
Behöver jag Redis?
För mer än en replik, ja — det håller budgetar och frekvensgränser konsekventa mellan repliker, bredvid Postgres och OpenFGA som produktion behöver ändå. Inbäddat läge behöver ingenting externt, men körs på en nod och håller sitt tillstånd i minnet.
Kör den på Kubernetes?
Ja, på två sätt. En egen operator deklarerar gatewayen och dess katalog som resurser — tillståndslösa repliker, skalning med HPA eller KEDA, delade budgeträknare samt hälso- och readiness-probes — och det finns ett Helm-chart om ni hellre driver det själva.
Är den verkligen Apache-2.0?
Ja. Gatewayens produktionsväg är Apache-2.0: routing, HA, cache, failover, budgetar, guardrails, MCP, jobb, observability och bevisliggaren. Enterprise lägger till identitet (SSO, SCIM, IdP-tokens), revisions- och bevispaket, agentbetalningar, godkännanden i Slack och Teams, guardrails för pass-through och support.
Ringer den hem?
Nej. Ingen telemetri och ingen analys, och licensen är en signerad offlinetoken utan licensserver. Den körs helt air-gapped: bevaka dess utgående anslutningar så ser ni bara de leverantörer ni har konfigurerat.
Tänk om vi behöver hjälp med migreringen?
Designpartner får handgripligt migreringsstöd, även från LiteLLM — vi gör den tillsammans med er i stället för att lämna över en guide.
En endpoint. Alla modeller. Full kontroll.
Kör den i er egen infrastruktur
Allt ni behöver för att köra en control plane i produktion är Apache-2.0 och förblir det — routing, HA, cache, failover, budgetar, policy, MCP, jobb och observability. Self-hosted, inget konto, ingen phone-home.
$ docker run -p 4000:4000 <registry>/waeg-gateway:<version>Ingen fungerande pull: avbilderna är inte publika än. Designpartner får registeruppgifterna privat.
Driftsätt på 5 minuterForma den som design partner
Wäg är ännu inte publikt släppt. Vi arbetar med en liten grupp team som kör AI från flera leverantörer i produktion och tar styrning och suveränitet på allvar, för att härda control plane:n mot verkliga arbetslaster.
- Alla Enterprise-funktioner ingår, utan licenskostnad
- Praktisk migrering — vi gör den tillsammans med er, även från LiteLLM
- En direktlinje till ingenjörerna som bygger den, och verkligt inflytande över vad som kommer härnäst