Scegliere il modello giusto per l’attività
Imparate a ridurre costi e latenza di RAG indirizzando ogni richiesta al modello meno costoso in grado di svolgere bene il compito, usando livelli di modello, cascades e quality gate.
Scegliere il modello giusto per l’attività è una lezione LLM Apps in Production (RAG + Vector DB + Caching) gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento LLM Apps in Production (RAG + Vector DB + Caching), e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso LLM Apps in Production (RAG + Vector DB + Caching) include 4 lezioni in totale.
Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.
Why Model Choice Drives Cost
In a RAG pipeline the LLM call is usually the single biggest cost and latency driver. The same prompt sent to a flagship model can cost 20-50x more than a small model.
Optimizing model selection is often the highest-leverage change you can make.
- Token price differs per model
- Latency scales with model size
- Not every query needs the biggest brain
Model Tiers
Group your available models into tiers by capability and price:
- Small / cheap — classification, extraction, simple Q&A
- Mid — most RAG answers grounded in retrieved context
- Large / flagship — multi-step reasoning, ambiguous queries
Default to the smallest tier that meets your quality bar.
A Simple Router
A router inspects the request and picks a model. Start with rule-based routing before adding ML.
def pick_model(query, context_len):
if len(query) < 80 and context_len < 2000:
return 'small-model'
if 'explain' in query or 'compare' in query:
return 'large-model'
return 'mid-model'
print(pick_model('What is the price?', 500))Model Cascades
A cascade tries a cheap model first, then escalates only if the answer is low confidence. Most queries resolve cheaply; only the hard ones reach the expensive model.
- Run small model
- Score confidence / check guardrails
- Escalate only on failure
Cascade in Code
A minimal cascade with a confidence check.
def answer(query):
cheap = call('small-model', query)
if cheap['confidence'] >= 0.8:
return cheap['text']
return call('large-model', query)['text']
def call(model, query):
return {'text': 'stub', 'confidence': 0.9}
print(answer('hello'))Confidence Signals
How do you know the cheap answer is good enough? Useful signals:
- Self-reported confidence from the model
- Whether the answer cites retrieved context
- Output length / refusal patterns
- A small judge model scoring the answer
Matching Context Size to Model
Large context windows are expensive. A model that accepts 200k tokens charges you for every token you send. Trim retrieved chunks aggressively and reserve big windows for queries that truly need them.
Right-sizing context is part of right-sizing the model.
Measuring Quality per Tier
Before downgrading a model, measure quality on a fixed eval set. Track accuracy per tier so you know the real trade-off.
scores = {'small': 0.81, 'mid': 0.90, 'large': 0.93}
bar = 0.88
cheapest_ok = next(m for m, s in scores.items() if s >= bar)
print('Use:', cheapest_ok)Cost vs Quality Curve
Plotting cost against quality usually shows diminishing returns: jumping to the flagship model buys a few points of accuracy at multiples of the cost.
Pick the point where quality crosses your acceptance bar at the lowest cost.
Fallbacks for Reliability
Routing also helps reliability. If your primary model is rate-limited or down, route to an alternative provider of similar tier so users still get answers.
- Primary -> secondary provider
- Same tier, comparable quality
- Log which path served the request
Putting It Together
A production router combines: tier rules, a cascade for hard queries, context trimming, and provider fallbacks. Continuously evaluate so routing stays calibrated as models change.
Quick Check
Test your understanding of model cascades.
Recap
You learned to cut RAG cost and latency by choosing the right model: tier your models, default to the smallest that meets your bar, use cascades to escalate only hard queries, right-size context, and keep provider fallbacks for reliability. Always validate routing against an eval set.
Domande Frequenti
La lezione «Scegliere il modello giusto per l’attività» è gratuita?
Sì — il testo completo di «Scegliere il modello giusto per l’attività» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso LLM Apps in Production (RAG + Vector DB + Caching), passa a CoddyKit PRO. Il corso LLM Apps in Production (RAG + Vector DB + Caching) include 4 lezioni in totale.
Cosa imparerò in «Scegliere il modello giusto per l’attività»?
Imparate a ridurre costi e latenza di RAG indirizzando ogni richiesta al modello meno costoso in grado di svolgere bene il compito, usando livelli di modello, cascades e quality gate. Eserciti LLM Apps in Production (RAG + Vector DB + Caching) con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare LLM Apps in Production (RAG + Vector DB + Caching)?
Non è richiesta alcuna esperienza precedente. LLM Apps in Production (RAG + Vector DB + Caching) su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Scegliere il modello giusto per l’attività»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione LLM Apps in Production (RAG + Vector DB + Caching)?
Sì. Ogni lezione LLM Apps in Production (RAG + Vector DB + Caching) include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Prompt engineering per l'efficienza
- Batching e operazioni asincrone
- Monitorare costi e latenza
- Scegliere il modello giusto per l’attività