Arquiteturas de Sistemas de IA
Chatbots, assistentes, copilots, agentes autônomos. Quando usar cada padrão.
Definição
Padrões arquiteturais para sistemas de IA: (1) Simple Q&A: prompt → response, sem estado. (2) Conversational: histórico de mensagens gerenciado. (3) RAG system: retrieval + generation. (4) Copilot: assistente inline que augmenta o trabalho humano (GitHub Copilot, Cursor). (5) Agent: loop autônomo com tools. (6) Multi-agent: múltiplos agentes especializados coordenados. A complexidade deve corresponder ao problema.
Problema → Solução
Problema
Usar arquitetura de agente autônomo para um caso que seria resolvido com uma simples chamada de API. Ou o oposto: tentar resolver com um prompt simples algo que requer múltiplos passos, estado e ferramentas.Solução
Começar simples: prompt → response. Adicionar RAG quando precisar de dados privados. Adicionar tools/function calling quando precisar de ações externas. Adicionar loop de agente quando precisar de múltiplos passos dependentes. Multi-agente só quando um agente único fica sobrecarregado ou quando paralelismo genuíno existe.Dica de entrevista
Tip
Agentes autônomos são mais difíceis de debugar, custam mais, e podem tomar ações inesperadas. Preferir Human-in-the-loop para ações irreversíveis. O princípio de menor privilégio se aplica: dê ao agente apenas as ferramentas que ele realmente precisa.Código
// Padrões arquiteturais lado a lado
// 1. Simple Q&A — sem estado
async function answer(question: string) {
return openai.chat.completions.create({
model: 'gpt-4o-mini',
messages: [{ role: 'user', content: question }]
})
}
// 2. Conversational — com histórico
class Chatbot {
private history: Message[] = []
async chat(userMessage: string) {
this.history.push({ role: 'user', content: userMessage })
const response = await callLLM([systemMsg, ...this.history])
this.history.push({ role: 'assistant', content: response })
return response
}
}
// 3. RAG — com retrieval
async function ragAnswer(question: string) {
const context = await vectorStore.search(question)
return callLLM([systemMsg, contextMsg(context), userMsg(question)])
}
// 4. Agent — loop com tools
async function agent(task: string) {
const tools = [searchTool, writeTool, codeTool]
for (let step = 0; step < MAX_STEPS; step++) {
const response = await callLLMWithTools(task, history, tools)
if (response.stopReason === 'end') return response.text
const result = await executeTool(response.toolCall)
history.push(response, toolResult(result))
}
throw new Error('Max steps reached')
}Perguntas de entrevista
Q.Quando usar multi-agentes vs agente único?▾
A.Multi-agentes quando: tasks genuinamente paralelas (pesquisador + redator + revisor), especialização necessária (agente de código separado do agente de análise), ou quando um único agente com muitas tools fica confuso. Desvantagem: orquestração complexa, mais latência, debugging difícil. Começar com agente único e só dividir quando justificado.
Q.O que é o padrão de Copilot?▾
A.Assistente que augmenta o humano em vez de substituir: GitHub Copilot (completa código), Notion AI (melhora texto), Cursor (edita arquivos). Diferente de agente autônomo: o humano sempre aprova as ações. Padrão: show diff, human approves, apply. Mais seguro e confiável que agentes autônomos para casos de uso de produção.
Q.Como garantir observabilidade em sistemas de agentes?▾
A.Tracing de cada passo do agente: qual tool foi chamada, com quais args, qual o resultado, quanto tempo levou. LangSmith, Braintrust, ou Arize para tracing. Métricas: taxa de sucesso por task type, número médio de steps, custo por tarefa. Alertas para: loop detection, custo anômalo, taxa de erro acima do threshold.
95/122← →