Mitme mudeli orkestreerimine: marsruutimine hinna, latentsi ja kvaliteedi järgi

Kõige kallim viga, mida me tootmises olevates AI-süsteemides näeme, on ühe mudeli kasutamine kõige jaoks.

Tiim valib GPT-5 (või Claude 4 Opuse või mõne muu lipulaeva mudeli). Nad ehitavad oma rakenduse selle ümber. Arved on viiekohalised igas kuus. Need saaks vähendada 60–90% võrra, kui suunata erinevad päringud erinevatesse mudelitesse — ja sageli parandab see samal ajal kvaliteeti.

See ongi mitme mudeli orkestreerimine: õige mudeli kasutamine iga ülesande jaoks süsteemis. See on vahe hobiprojekti-AI ja tootmises oleva AI vahel.

See artikkel käsitleb mustreid, marsruutimise loogikat, kompromisse ja annab samm-sammult juhise selle rakendamiseks.

Miks üks mudel ei ole optimaalne

1. aastal pakutavad mudelid jagunevad ligikaudu sellistesse tasanditesse:

Lipulaeva arutlusmudelid (GPT-5, Claude 4 Opus, Gemini 3 Pro, o3): suurepärased keerukas arutlemises, kallid (2–15 € miljoni sisendmärgi kohta, 10–60 € miljoni väljundmärgi kohta), aeglasemad (tüüpiliselt 5–30 sekundit).

Lipulaeva üldmudelid (GPT-5 turbo, Claude 4 Sonnet, Gemini 3 Pro Flash): suurepärased enamikus teadmustöös, mõõdukalt kallid (0,50–3 € miljoni sisendi kohta, 5–15 € miljoni väljundi kohta), mõistlik kiirus (2–5 sekundit).

Keskklassi mudelid (GPT-5 Mini, Claude 4 Haiku, Gemini 3 Flash): head lihtsate kuni mõõdukate ülesannete puhul, odavad (0,10–0,50 € miljoni sisendi kohta, 0,50–2 € miljoni väljundi kohta), kiired (1–2 sekundit).

Väikesed mudelid (GPT-5 Nano, Claude Haiku Lite, Gemini Flash Lite): head lihtsate struktureeritud ülesannete puhul, väga odavad (0,02–0,10 € miljoni märgi kohta), väga kiired (<1 sekund).

Spetsialiseeritud mudelid (embedding-mudelid, ümberjärjestamise mudelid, nägemismudelid, kõnemudelid): optimeeritud konkreetsete ülesannete jaoks, sageli väga odavad, sest nad on fokuseeritud.

Tüüpiline AI-rakendus teeb palju erinevat tüüpi LLM-kõnesid. Igal kõnel on oma nõuded:

• Kasutaja kavatsuse klassifitseerimine: vajab lihtsat klassifikatsiooni, kiiret vastust. Keskklassi mudel sobib ideaalselt.
• Struktureeritud andmete ekstraktimine dokumentidest: vajab usaldusväärsust struktureeritud väljundis, mõõdukat keerukust. Keskklass või lipulaeva üld.
• Tegeliku vastuse koostamine kasutaja päringule: vajab kvaliteeti, konteksti käsitlemist. Lipulaeva üld või lipulaeva arutlus.
• Eelmise vestluse kokkuvõtete genereerimine: lihtne kokkuvõtmine. Keskklass või väike mudel.
• Taustal toimuv pakkpartiide töötlemine: ei ole latentsitundlik, kuid maht loeb. Väike või keskklass.

Lipulaeva kasutamine kõige selle jaoks on raiskamine. Klassifikatsioon seda ei vaja. Kokkuvõtmine seda ei vaja. Struktureeritud ekstraktimine sageli samuti mitte. Ainult kasutajale suunatud vastus saab sellest tõelist kasu.

Kulukokkuhoid on reaalne

Tüüpilises teadmustöö AI-rakenduses võib päringute jaotus välja näha nii:

• 60% LLM-kõnedest: lihtne klassifikatsioon, ekstraktimine, kokkuvõtmine. Kõige paremini sobivad keskklassi või väikesed mudelid.
• 30% kõnedest: mõõdukas keerukus. Keskklass või lipulaeva üld.
• 10% kõnedest: keerukas arutlemine või lõplik kasutajavastus. Lipulaev.

Kui kasutad kõige jaoks lipulaeva, on kulu 100% lipulaeva hinnast. Kui marsruudid asjakohaselt:

• 60% väikese mudeli hinnaga (1/30 lipulaeva omast): 2% algsest kulust.
• 30% keskklassi hinnaga (1/5 lipulaeva omast): 6% algsest kulust.
• 10% lipulaeva hinnaga: 10% algsest kulust.

Kokku: 18% algsest kulust. 82% kokkuhoid. 10 000 €/kuu arve puhul on see 8200 €/kuu säästu.

Need numbrid sõltuvad sinu liikluse profiilist, kuid muster on järjepidev: enamikus rakendustes on päringute mix selline, et keskmine kõne on palju odavam kui kõige raskem kõne. Marsruutimine püüab selle kinni.

Põhilised orkestreerimise mustrid

Tootmises olevates mitme mudeli süsteemides korduvad mõned mustrid:

Muster 1: Ülesandepõhine marsruutimine

Erinevat tüüpi ülesanded lähevad erinevatesse mudelitesse. See on kõige lihtsam muster.

def route_request(task_type):
    if task_type == "classification":
        return "gpt-5-nano"
    elif task_type == "extraction":
        return "gpt-5-mini"
    elif task_type == "summarization":
        return "claude-4-haiku"
    elif task_type == "user-facing-response":
        return "claude-4-sonnet"
    elif task_type == "complex-reasoning":
        return "claude-4-opus"

Ülesanded klassifitseerib kutsuv kood (ta teab, mida ta küsib). Marsruutimine on deterministlik ja lihtne silumiseks.

Muster 2: Keerukusepõhine marsruutimine

Süsteem hindab iga päringu keerukust ja marsruudib selle vastavalt.

def route_by_complexity(request):
    complexity = estimate_complexity(request)
    if complexity < 3:
        return "small"
    elif complexity < 7:
        return "mid"
    else:
        return "flagship"

Keerukuse hinnang võib olla heuristiline (päringu pikkus, märksõnade tuvastamine) või mudelipõhine (odav klassifikaator hindab päringu). See muster lahendab juhtumeid, kus sama ülesandetüüp varieerub raskusastmelt.

Muster 3: Kaskaadmarsruutimine

Proovi kõigepealt odavat mudelit. Kui väljund on hea, kasuta seda. Kui mitte, eskaleeri kallima mudelini.

def cascade(request):
    cheap_response = call_model("small", request)
    if is_acceptable(cheap_response):
        return cheap_response
    return call_model("flagship", request)

See toimib siis, kui „vastuvõetav" on tuvastatav — kindlustunde skooride, valideerijate või eraldiseisva kvaliteedikontrolli-LLM-i abil. See on võimas: enamikule lihtsatele päringutele vastab odav mudel; ainult rasked jõuavad kalli mudelini.

Muster 4: Spetsialiseeritud marsruutimine

Kasuta spetsialiseeritud mudeleid spetsialiseeritud ülesannete jaoks:

• Embedding'ud: kasuta selleks mõeldud embedding-mudelit (palju odavam kui chat-mudel, mida kasutatakse embedimiseks).
• Ümberjärjestamine: kasuta selleks mõeldud reranker'it.
• Nägemine: kasuta nägemisele spetsialiseeritud mudelit pilditöötluseks.
• Hääl: kasuta häälemudelit transkribeerimiseks/sünteesiks.
• Kood: kasuta koodile spetsialiseeritud mudelit kooditöödeks.

Spetsialiseeritud mudelid on tavaliselt kiiremad, odavamad ja paremad oma konkreetses ülesandes kui üldmudel, mis sama asja proovib.

Muster 5: Pakkuja-marsruutimine

Kasuta mudeleid mitmelt pakkujalt liiasuse ja hindade võimenduse jaoks.

providers = ["openai", "anthropic", "google"]
preferred = "anthropic"  # primary
fallback = "openai"      # fallback

def call_with_failover(request):
    try:
        return call(preferred, request)
    except (RateLimit, ProviderError):
        return call(fallback, request)

See annab vastupidavuse ühe pakkuja tõrgete ja päringupiirangute vastu. Samuti võimaldab see ära kasutada hinnamuutusi — kui pakkuja langetab hindu, suuna sinna rohkem liiklust.

Realistlik näide: klienditoe AI

Et asja konkreetseks teha, vaatame, kuidas klienditoe AI võiks mitme mudeli orkestreerimist kasutada.

Süsteemil on igale piletile järgmised sammud:

Samm 1: Klassifitseeri kavatsus. Mille kohta klient küsib? (5–10 kategooriat.)

Marsruutimine: GPT-5 Nano. See on lihtne klassifitseerimisülesanne. Kulu: ~0,0001 € pileti kohta.

Samm 2: Määra kiireloomulisus ja sentiment. Kas klient on pahane? Kas see on kiireloomuline?

Marsruutimine: GPT-5 Nano. Veel üks lihtne klassifikatsioon. Kulu: ~0,0001 € pileti kohta.

Samm 3: Otsi asjakohaseid teadmisi.

Marsruutimine: embedding-mudel + ümberjärjestamise mudel. Spetsiaalsed tööriistad spetsiaalse töö jaoks. Kulu: ~0,0002 € pileti kohta.

Samm 4: Otsusta, kas AI saab sellele vastata või on vaja inimene appi tuua.

Marsruutimine: Claude 4 Haiku. Veidi keerukam klassifikatsioon, võttes arvesse otsitud konteksti. Kulu: ~0,001 € pileti kohta.

Samm 5 (kui AI saab vastata): Genereeri kliendile suunatud vastus.

Marsruutimine: Claude 4 Sonnet. Kvaliteet loeb siin — seda klient loeb. Kulu: ~0,02 € pileti kohta.

Samm 6 (kui AI ei saa vastata): Genereeri kokkuvõte inimagendile.

Marsruutimine: GPT-5 Mini. Kasulik kokkuvõte, mitte kliendile suunatud. Kulu: ~0,005 € pileti kohta.

Samm 7: Kvaliteedikontroll. Kas vastus vastas meie standarditele?

Marsruutimine: Claude 4 Haiku kiire kohtunikuna. Kulu: ~0,001 € pileti kohta.

Piletite puhul, millele AI vastab (ütleme 70%):

• Kogukulu pileti kohta: ~0,024 €

Inimestele eskaleeritud piletite puhul (30%):

• Kogukulu pileti kohta: ~0,008 €

Kaalutud keskmine: ~0,019 € pileti kohta.

Kui meeskond oleks kõige jaoks kasutanud lipulaeva arutlusmudelit: ~0,30 € pileti kohta. Mitme mudeli lähenemine säästab 94%.

1000 pileti puhul päevas on see 280 €/päev → 100 000 € säästu aastas.

Marsruutimise loogika

Mõned lähenemised marsruutimise rakendamiseks:

Lähenemine 1: Kõvasti kodeeritud ülesandetüübi järgi

Kõige lihtsam. Sa tead, mis ülesannet kutsud, sa valid mudeli.

def classify(text):
    return openai_client.chat.completions.create(
        model="gpt-5-nano",
        messages=[{"role": "user", "content": f"Classify: {text}"}],
    )

def respond(context, query):
    return claude_client.messages.create(
        model="claude-4-sonnet",
        messages=[{"role": "user", "content": f"Context: {context}\n\nQuery: {query}"}]
    )

Plussid: läbipaistev, kerge siluda, kerge muuta. Miinused: ei kohandu päringu keerukusega ülesandetüübi sees.

Lähenemine 2: Marsruuter-mudel

Väike mudel klassifitseerib iga päringu ja marsruudib selle.

ROUTER_PROMPT = """
Classify this request as: trivial, moderate, or complex.
Output one word.

Request: {request}
"""

def route(request):
    classification = small_model_call(ROUTER_PROMPT.format(request=request))
    return MODEL_BY_COMPLEXITY[classification]

Plussid: kohandub kategooria sisesele keerukusele. Miinused: lisab latentsust (marsruuteri kõne), lisab tõrkepunkti, vajab häälestamist.

Lähenemine 3: Embedding-põhine marsruuter

Päringute puhul, mis kuuluvad tuntud mustritesse, kasuta embedding-sarnasust varasemate näidetega.

def route(request):
    embedding = embed(request)
    closest = find_nearest_example(embedding)
    return closest.suggested_model

Plussid: kiire (lihtsalt vektorotsing), läheb andmetega targemaks. Miinused: nõuab märgistatud näidiste komplekti ülesehitamist.

Lähenemine 4: Kaskaad

Proovi kõigepealt odavat; eskaleeri vajadusel.

def cascade(request):
    cheap = small_model_call(request)
    if validates(cheap):
        return cheap
    return flagship_call(request)

Plussid: kohanev, madal keskmine kulu. Miinused: aeglane juhtumitele, mis vajavad eskaleerimist (kaks kõnet), nõuab usaldusväärset valideerimist.

Praktikas kasutavad paljud tootmissüsteemid hübriidi: kõvasti kodeeritud marsruutimine peamiste ülesandetüüpide jaoks, koos kaskaadidega konkreetsete suure varieeruvusega alatüüpide jaoks.

Lõksud

Mõned vead, mida vältida:

Lõks 1: Kulude optimeerimine kvaliteedi halvenemise hinnaga

On lihtne suunata kõik väikestesse mudelitesse ja vaadata, kuidas kulu langeb. On raskem märgata, et kvaliteet langes ka. Pari marsruutimismuudatused alati kvaliteedi jälgimisega.

Kasulik distsipliin: kui sa nihutad ülesande odavamasse mudelisse, tee sellega nädal aega A/B-testi koos kvaliteedimõõdikutega. Ära lükka muudatust välja ilma tõenditeta, et kvaliteet püsis.

Lõks 2: Marsruuteri üledisain

Marsruuter, mis käsitleb 100 ülesandetüüpi keeruka loogikaga, on raskem hooldada kui marsruutimine, mille see asendab. Alusta lihtsast. Kui lihtne versioon on 80% sama hea kui keerukas versioon, lükka välja lihtne versioon.

Tavaline muster: 50-realine marsruuter, mis käsitleb 5–10 ülesandetüüpi, katab 90% kasust. Sealt edasi tasuvus väheneb.

Lõks 3: Latentsuse ignoreerimine

Odavamad mudelid on tavaliselt ka kiiremad — mis on hea. Aga kui sa kaskaadid (proovi odavat, siis lipulaeva), võid raskete juhtumite latentsuse kahekordistada. Kasutajale suunatud voogudes see loeb.

Kasulik muster: kasutajale suunatud latentsitundlike vastuste puhul vaikimisi lipulaev ja aktsepteeri kulu. Hoia kaskaadid pakettöö või asünkroonse töö jaoks.

Lõks 4: Pakkujate tõrgete eiramine

Kui sõltud mitmest mudelist, on sul mitu võimalust ebaõnnestumiseks. Lipulaeva mudel läheb maha, päringupiirang lööb sisse, API-võti aegub. Sinu marsruutimise loogika vajab varuvariante.

Miinimum: igal „peamisel" mudelil peaks olema „varu"-mudel teiselt pakkujalt. Isegi kui kvaliteet varu puhul langeb, süsteem jääb püsti.

Lõks 5: Marsruudi-põhise kvaliteedi mittemõõtmine

Sa pead teadma, milline marsruut töötab hästi ja milline mitte. See tähendab hindamist, ideaalis automatiseeritud.

Kasulik seadistus: iga tootmiskõne kohta logi kasutatud mudel, päring, vastus ja (kui võimalik) mingi kvaliteedisignaal (kasutaja tagasiside, järgneva etapi mõõdikud, automaatne hindamine). Tee marsruudipõhised mõõdikud kokkuvõttena. Püüa kvaliteedi triivimine kinni enne, kui kasutajad kurdavad.

Kuhu see liigub

Mõned trendid, mida oodata:

Auto-marsruutimine teenusena. Tööriistad nagu OpenRouter, Helicone, Portkey ja teised pakuvad üha enam „nutikat marsruutimist" — nad valivad mudeli sinu eest konfigureeritavate reeglite põhjal. Oota selle märkimisväärset küpsemist.

Mudelipõhine spetsialiseerumine kasvab. Mudelid spetsialiseerunud koodile, matemaatikale, konkreetsetele valdkondadele. Marsruutimine hõlmab üha enam spetsialiseeritud mudeleid.

Hinnad langevad edasi. 2026. aasta mudelid on 10x odavamad kui sama kvaliteet 2024. aastal. 2028. aastaks oota veel 10x. Mitme mudeli orkestreerimise majandus paraneb edasi.

Seadmesisesed tasandid. Telefonid ja sülearvutid kohaliku AI-võimekusega pakuvad „tasuta" tasandit mõnede päringute jaoks. Marsruutimise loogika hõlmab üha enam „jää seadmele, kui võimalik".

Standarditud API-d pakkujate vahel. OpenAI-ga ühilduvad API-d (juba laialdaselt kasutusel) tähendavad, et pakkujate vahetamine on üha triviaalsem. Oota rohkem standardiseerimist, mis muudab mitme pakkuja strateegiad lihtsamaks.

Algajatele mõeldud kontrollnimekiri

Kui ehitad mitme mudeli süsteemi nullist või migreerid ühe mudeli süsteemist:

1. Kaardista oma ülesanded. Mis tüüpi LLM-kõnesid sinu rakendus teeb? Umbes kui sageli? Umbes kui kallid?

1. Kategoriseeri keerukuse järgi. Iga ülesandetüübi puhul otsusta: triviaalne, mõõdukas või keeruline. Vasta mudelite tasanditele.

1. Ehita marsruuter. Alusta kõvasti kodeeritud ülesandepõhisest marsruutimisest. Ära üledisaini.

1. Lisa varuvariandid. Igal põhimudelil peaks olema varu (teine pakkuja).

1. Mõõda kvaliteeti marsruudi kaupa. Sea üles logimine ja põhihindamine. Sa pead teadma, kas kvaliteet püsib.

1. Itereeri. Vii ülesandeid odavamatesse mudelitesse, kus kvaliteet püsib. Vii ülesandeid tagasi kallimatesse mudelitesse, kus kvaliteet murdub. Kohanda aja jooksul.

1. Ära lõpeta häälestamist. Mudelid muutuvad. Tulevad uued. Hinnad nihkuvad. Marsruutimisseadistus, mis on mais 2026 optimaalne, võib olla novembris 2026 ebaoptimaalne.

Kokkuvõte

Mitme mudeli orkestreerimine on üks kõige kõrgema ROI-ga muudatusi, mida saad tootmises olevas AI-süsteemis teha. Hästi tehtuna vähendab see kulusid 60–90% ja parandab sageli kvaliteeti (sest iga ülesanne kasutab talle sobivat mudelit).

Tehniline lävi on madal — põhiline marsruutimise loogika on paarkümmend rida koodi. Distsipliini lävi on kõrgem: sa pead kvaliteeti pidevalt mõõtma, et veenduda marsruutimisotsuste püsimises.

Lõpeta ühe mudeli kasutamine kõige jaoks. Kaardista oma ülesanded. Vali igale õige mudel. Mõõda tulemust. Itereeri. Kokkuhoid on reaalne ja kvaliteediparandused on tavaliselt boonus.