Hoe LLM-verzoeken per taak naar het juiste model te routeren

Kort antwoord: routeer aanvragen in uw applicatie, gebruik vervolgens één CometAPI-sleutel en de OpenAI-compatibele basis-URL https://api.cometapi.com/v1 om het geselecteerde model aan te roepen. Stuur repetitief, eenvoudig te controleren werk naar een low-cost tier; latency-gevoelige klantinteracties naar een snelle tier; en ambigu of high-impact werk naar een tier met hoge nauwkeurigheid. Behoud de labels als uw eigen beleid—niet als een universele modelrangorde—en meet elke tier op dezelfde testset.

Deze gids bouwt die router met drie tiers met een compact Python-voorbeeld, begrensde fallback en een kostenmodel dat retries en afgekeurde outputs meetelt. Het voorbeeld gebruikt actuele model-ID’s uit de CometAPI-catalogus, maar de routeringslogica blijft apart zodat modellen vervangen kunnen worden zonder de applicatie te herschrijven.

Wat is LLM-routing?

LLM-routing is het proces waarbij elke aanvraag wordt gestuurd naar het model of de servicetier die het best past bij de taak, latencydoel, kwaliteitsvereiste en het budget.

Hoe routeert u LLM-aanvragen per taak?

Per 20 augustus 2026 waren de volgende model-ID’s en catalogusprijselementen beschikbaar via de publieke CometAPI Models API. De onderstaande geschatte consumentenprijzen passen de huidige ratio-waarde uit de catalogus toe op de input- en output-basistarieven, conform de CometAPI-prijsgids. Bevestig het definitieve tarief dat voor uw account wordt getoond voordat u in productie gaat.

“Snel” betekent dat de route een latencydoel heeft; “hoge nauwkeurigheid” betekent dat deze een strikter kwaliteitsdoel heeft. Geen van beide labels bewijst dat één model altijd het snelst of het meest nauwkeurig is. Benchmark p50- en p95-latency, taalslagingspercentage en kosten per geaccepteerde output op uw eigen verkeer voordat u de mapping definitief maakt.

Hoe stelt u CometAPI in voor een LLM-router?

U hebt een CometAPI-API-sleutel, Python 3.10 of hoger en het OpenAI Python-pakket nodig. Sla de sleutel server-side op en niet in de broncode.

pip install openaiexport COMETAPI_KEY="your-key-here"

Het voorbeeld gebruikt POST /v1/chat/completions. CometAPI documenteert dit als een gedeelde interface voor meerdere providers, maar het gedrag van parameters kan per model variëren. Controleer het huidige modelitem en de Chat Completions reference voordat u provider-specifieke velden toevoegt.

Wat hebt u nodig om een LLM-router te bouwen?

• Map stabiele taken naar servic Tiers. Vraag niet een andere LLM om elke aanvraag te classificeren, tenzij eenvoudige applicatiesignalen onvoldoende zijn. Een supportlabel is voorspelbaar low-cost werk; een live antwoord is latency-gevoelig; een beleidsreview verdient de strengste kwaliteitsgate.
• Valideer de output. Een succesvolle HTTP-status betekent niet dat het resultaat bruikbaar is. Geef een taakspecifieke validator mee aan de router. Een classificatievalidator kan een toegelaten label controleren; een validator voor klantantwoorden kan lengte en verboden claims afdwingen; een gestructureerde workflow kan een JSON-schema valideren.
• Fallback beperkt inzetten. Probeer de volgende goedgekeurde route na een timeout, 408, 429, tijdelijke 5xx of een begrensde kwaliteitsgate-fout. Gebruik geen ander model om onjuist geformatteerde input, een ongeldige sleutel of niet-ondersteunde parameters te verhullen.

Hoe bouwt u een LLM-router in Python?

import osimport time​from openai import APIError, OpenAI​client = OpenAI(    api_key=os.environ["COMETAPI_KEY"],    base_url="https://api.cometapi.com/v1",    max_retries=0,    timeout=20,)​MODELS = {    "cheap": "deepseek-v4-flash",    "fast": "gemini-3.7-flash",    "accurate": "claude-opus-5",}​# Put the preferred tier first; later tiers are fallbacks.ROUTES = {    "tag": ["cheap", "fast", "accurate"],    "reply": ["fast", "cheap", "accurate"],    "policy_review": ["accurate", "fast", "cheap"],}​​def retryable(error):    status = getattr(error, "status_code", None)    return status is None or status in {408, 429} or (status and status >= 500)​​def route(task, prompt, validate=lambda text: True):    attempts = []    for tier in ROUTES.get(task, ROUTES["reply"]):        model = MODELS[tier]        started = time.perf_counter()        try:            response = client.chat.completions.create(                model=model,                messages=[{"role": "user", "content": prompt}],                max_tokens=400,            )            text = response.choices[0].message.content or ""            attempts.append({                "tier": tier,                "model": model,                "latency_ms": round((time.perf_counter() - started) * 1000),                "accepted": validate(text),            })            if attempts[-1]["accepted"]:                return {                    "text": text,                    "route": tier,                    "model": model,                    "usage": response.usage.model_dump() if response.usage else None,                    "attempts": attempts,                }        except APIError as error:            attempts.append({"tier": tier, "model": model, "status": error.status_code})            if not retryable(error):                raise​    raise RuntimeError(f"No route passed: {attempts}")​​if __name__ == "__main__":    result = route(        "reply",        "Reply to a customer asking when their refund will arrive. Do not promise a date.",        validate=lambda text: 30 <= len(text) <= 600 and "guarantee" not in text.lower(),    )    print(result)

Hoe begrenst u retries vóór fallback?

Laat SDK-retries op nul en omhul elke modelaanroep met een expliciete limiet. De helper hieronder retryt alleen retrybare API-fouten één keer en gooit dan een exceptie zodat de buitenste route naar de volgende goedgekeurde tier kan gaan.

MAX_ATTEMPTS_PER_MODEL = 2​def call_model(model, prompt):    for attempt in range(1, MAX_ATTEMPTS_PER_MODEL + 1):        try:            return client.chat.completions.create(                model=model,                messages=[{"role": "user", "content": prompt}],                max_tokens=400,            )        except APIError as error:            if not retryable(error) or attempt == MAX_ATTEMPTS_PER_MODEL:                raise            time.sleep(min(0.5 * (2 ** (attempt - 1)), 2.0))

In route() vervangt u de directe aanroep client.chat.completions.create(...) door call_model(model, prompt). Met drie tiers stopt één aanvraag na maximaal zes provideraanroepen; validatiefouten escaleren nog steeds één keer per tier in plaats van hetzelfde outputresultaat te herhalen.

Voer uit met python3 llm_task_router.py. Om later providers of modelgeneraties te wijzigen, werkt u MODELS bij; het taakbeleid en het responsecontract blijven op één plek.

Het voorbeeld gebruikt alleen parameters die door de geselecteerde modellen worden gedeeld. Voeg model-specifieke tokenbesturing toe via een adapterlaag nadat u modelcompatibiliteit hebt gecontroleerd.

Hoe test u een LLM-routeringsbeleid?

Controleer eerst dat het deterministische beleid de beoogde primaire tier selecteert. Dit zijn routeringsverwachtingen, geen providerprestatie-resultaten:

Een geslaagde live smoke test retourneert het antwoord plus de geselecteerde tier, model-ID, tokengebruik en elke poging. Werkelijke token- en latencywaarden variëren:

{  "text": "...",  "route": "fast",  "model": "gemini-3.7-flash",  "usage": {    "prompt_tokens": "measured value",    "completion_tokens": "measured value"  },  "attempts": [    {      "tier": "fast",      "model": "gemini-3.7-flash",      "latency_ms": "measured value",      "accepted": true    }  ]}

Voor een echte vergelijking laat u dezelfde gelabelde aanvragen door alle drie de modellen lopen. Registreer taalslagingspercentage, p50- en p95-latency, foutpercentage, input- en outputtokens, fallback-percentage en human-review-percentage. De maatstaf die meestal telt is de kosten per geaccepteerde output, niet de kosten per API-call.

Wat kost multi-model routing?

Gebruik één workloadvorm voor een eerlijke vergelijking. Ga uit van in totaal 1 miljoen tokens: 800.000 inputtokens en 200.000 outputtokens. Met de catalogusafgeleide tarieven die op 20 augustus 2026 zijn gecontroleerd:

Als het verkeer 60% goedkoop, 30% snel en 10% hoge nauwkeurigheid is, bedraagt de geprojecteerde gemengde tokenkost ongeveer $1.19 per 1 miljoen totale tokens. Hetzelfde verkeer volledig naar de route met hoge nauwkeurigheid sturen, zou ongeveer $7.20 zijn onder deze aannames. Dit is een prijsberekening, geen bewijs dat het gemengde beleid aan uw kwaliteitsdoel zal voldoen.

Retries en afwijzingen veranderen het resultaat. Een eenmalig retrypercentage van 5% verhoogt de $1.19-projectie tot ongeveer $1.25. Als een low-cost output de validatie niet haalt en de volledige aanvraag opnieuw wordt uitgevoerd op de tier met hoge nauwkeurigheid, tel dan beide calls mee. Volg geaccepteerde outputs, zodat een ogenschijnlijk goedkoop model geen review- of regeneratiekosten verbergt.

Wat zijn de meest voorkomende LLM-routeringsfouten?

De error- en retry-gids beveelt aan om rate limits en tijdelijke platformstoringen met backoff te retryen, terwijl onjuist opgemaakte aanvragen en authenticatiefouten moeten worden hersteld. De fallback-gids houdt model-fallback eveneens geordend en expliciet.

Applicatierouting vs. CometAPI Auto: wat gebruikt u?

Gebruik applicatierouting wanneer controle en reproduceerbaarheid belangrijk zijn. Houd de beslissing in uw code wanneer taken stabiel zijn en u vaste modelidentiteiten, budgets per tier, aangepaste validators en een auditbare fallbackvolgorde nodig hebt. Deze aanpak maakt het ook eenvoudiger om dezelfde modelmapping over releases heen te vergelijken.

Gebruik CometAPI Auto wanneer het verminderen van routeringsonderhoud belangrijker is. Stel model=auto in voor een gebalanceerde standaard of model=auto-high wanneer kwaliteit hogere prioriteit heeft. CometAPI selecteert dynamisch een in aanmerking komend model op basis van de aanvraagkenmerken en de huidige routeringspool, zodat het onderliggende model kan variëren; dat maakt Auto minder geschikt wanneer elke run hetzelfde model of model-specifieke parameters moet gebruiken.

Hoe draait u LLM-routing in productie?

• Vernieuw het modelregister. Roep GET https://api.cometapi.com/api/models aan tijdens deployment of startup en laat de release falen als een geconfigureerde ID of vereist endpoint ontbreekt. Model-ID’s, prijzen en mogelijkheden kunnen veranderen.
• Houd provider-specifieke opties buiten de router. Een gemeenschappelijke Chat Completions-interface maakt niet elke parameter identiek. Ondersteuning voor bijvoorbeeld logprobs, reasoning-controls of meerdere candidates kan verschillen. Plaats die verschillen in geteste adapters.
• Beperk verkeer en output. Limiteer gelijktijdigheid voordat aanvragen de applicatie verlaten, gebruik exponentiële backoff met jitter voor 429 en stel een limiet in op outputtokens. De rate-limit-gids van CometAPI beveelt dezelfde applicatiekant-controles aan.
• Log de beslissing. Registreer taaktype, beleidversie, gekozen tier, model-ID, latency, tokengebruik, validatieresultaat, aantal retries, fallbackreden en kostenraming. Vermijd het loggen van geheimen of onnodige klantinhoud.
• Promoveer routes met bewijs. Houd een gelabelde evaluatieset per taak bij. Rol mappingwijzigingen geleidelijk uit, vergelijk ze met het vorige beleid en behoud een snelle rollback-mogelijkheid.

Veelgestelde vragen

Bepaalt CometAPI automatisch welk model goedkoop, snel of nauwkeurig is?

Deze tutorial houdt dat beleid in applicatiecode. CometAPI levert de gedeelde sleutel, basis-URL, modelcatalogus, Chat Completions-interface en gedocumenteerde fallback-bouwstenen. Uw team definieert wat elke tier betekent en welk model zijn tests heeft doorstaan.

Kan één CometAPI-sleutel modellen van verschillende providers aanroepen?

Ja. Gebruik voor OpenAI-compatibele tekstroutes https://api.cometapi.com/v1 en wijzig de model-waarde. De huidige catalogus moet vóór deployment worden gecontroleerd.

Waarom niet elke aanvraag naar het goedkoopste model sturen?

Het laagste token-tarief kan duur worden als outputs de validatie niet halen, retries vereisen of menselijk reviewwerk creëren. Vergelijk kosten per geaccepteerd resultaat en houd high-impact taken achter strengere kwaliteitsgates.

Moet een kwaliteitsfout een fallback triggeren?

Alleen wanneer de fout machine-detecteerbaar is en de escalatie begrensd is. Een schemafout, ontbrekend verplicht veld of verboden belofte kan één escalatie rechtvaardigen. Vage ontevredenheid moet evaluatiedata worden en geen onbeperkte retryloop.

Hoe vaak moet de modelmapping veranderen?

Verander wanneer actuele catalogusdata en een herhaalbare evaluatie een betere afweging laten zien. Roteer modellen niet alleen omdat er een nieuwe naam in de catalogus verschijnt.

Kan ik later een OpenAI-model toevoegen?

Ja. Voeg een actueel, OpenAI-compatibel model-ID toe aan MODELS, test hetzelfde request- en responsecontract en plaats het in de routevolgorde. De client, sleutel en basis-URL blijven ongewijzigd.

Hoe houdt u een LLM-routeringsbeleid beheersbaar?

De eenvoudigste multi-provider router is geen autonoom black box. Het is een korte, versieerbare taakpolicy ondersteund door gedeelde API-toegang, actuele modelmetadata, een kwaliteitsvalidator en een smalle fallbackketen. CometAPI reduceert het verbindingswerk tot één sleutel en één OpenAI-compatibele basis-URL; uw applicatie behoudt de controle over kosten-, latency- en kwaliteitsbeslissingen.