Escolhendo o modelo certo para a tarefa
Aprenda a reduzir custos e latência do RAG encaminhando cada solicitação ao modelo mais barato capaz de realizar bem a tarefa, usando níveis de modelos, cascatas e barreiras de qualidade.
Escolhendo o modelo certo para a tarefa é uma aula grátis de LLM Apps in Production (RAG + Vector DB + Caching) no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de LLM Apps in Production (RAG + Vector DB + Caching), e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de LLM Apps in Production (RAG + Vector DB + Caching) inclui 4 aulas no total.
Partes desta aula ainda não foram traduzidas e aparecem em inglês.
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.
Perguntas Frequentes
A aula “Escolhendo o modelo certo para a tarefa” é grátis?
Sim — o texto completo de “Escolhendo o modelo certo para a tarefa” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de LLM Apps in Production (RAG + Vector DB + Caching), atualize para CoddyKit PRO. O curso de LLM Apps in Production (RAG + Vector DB + Caching) inclui 4 aulas no total.
O que vou aprender em “Escolhendo o modelo certo para a tarefa”?
Aprenda a reduzir custos e latência do RAG encaminhando cada solicitação ao modelo mais barato capaz de realizar bem a tarefa, usando níveis de modelos, cascatas e barreiras de qualidade. Você pratica LLM Apps in Production (RAG + Vector DB + Caching) com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar LLM Apps in Production (RAG + Vector DB + Caching)?
Nenhuma experiência prévia é necessária. LLM Apps in Production (RAG + Vector DB + Caching) no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Escolhendo o modelo certo para a tarefa”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de LLM Apps in Production (RAG + Vector DB + Caching)?
Sim. Cada aula de LLM Apps in Production (RAG + Vector DB + Caching) inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Engenharia de Prompts para Eficiência
- Processamento em Lotes e Operações Assíncronas
- Monitoramento de Custos e Latência
- Escolhendo o modelo certo para a tarefa