O QUE É ARQUITETURA GENAI?
Arquitetura GenAI é o design de sistemas que integram Large Language Models (LLMs) em aplicações enterprise, combinando retrieval, geração e orquestração para criar soluções inteligentes.
Padrões, ferramentas e melhores práticas para construir sistemas de IA Generativa em produção. Um guia completo para arquitetos e engenheiros.
Arquitetura GenAI é o design de sistemas que integram Large Language Models (LLMs) em aplicações enterprise, combinando retrieval, geração e orquestração para criar soluções inteligentes.
Leitura complementar
Se você está começando agora, recomendo ler antes a trilha de fundamentos. Ela cobre arquitetura de software, dados, IA e observabilidade do zero, sem assumir conhecimento prévio.
Provedores API · atualizado em ago/2026
| Modelo | Contexto | Força | Provedor |
|---|---|---|---|
Claude Opus 4.8SOTA | 200K | Estado da arte em código e raciocínio longo | Anthropic |
Claude Sonnet 5API | 200K | Equilíbrio custo-performance | Anthropic |
Claude Haiku 4.5API | 200K | Alto volume, baixo custo | Anthropic |
GPT-5.4 / 5.5API | até 1M | Raciocínio, uso de computador, fluxos agênticos | OpenAI |
Gemini 3.1 ProAPI | 1M | Multimodal, raciocínio profundo | |
Gemini 3.5 FlashAPI | 1M | Coding agêntico, custo-benefício |
Acima do Opus, a Anthropic opera o tier Mythos, com o Claude Fable 5 disponível e o Claude Mythos 5 ainda restrito a um grupo reduzido de organizações.
Open-Source (Self-Hosted)
| Modelo | Params | Caso de Uso |
|---|---|---|
LlamaOSS | família | Controle total, fine-tuning, edge |
QwenOSS | família | Multilingual, coding |
MixtralOSS | MoE | Custo-benefício em self-hosting |
DeepSeekOSS | família | Raciocínio, custo baixo |
Orquestração
Protocolos de Agente
Model Serving
Observabilidade & LLMOps
Guardrails & Segurança
Leitura complementar
O ecossistema de protocolo de agente mudou bastante nos últimos meses. Escrevi sobre como decido entre os frameworks, e sobre a distinção operacional entre MLOps, LLMOps e AgentOps.
Retrieval-Augmented Generation é uma técnica que conecta o LLM a fontes externas (documentos, bancos de dados), recuperando dados relevantes antes de gerar a resposta, garantindo fundamentação factual.
Pipeline RAG Moderno
Vantagens
Limitações
Casos de Uso Ideais
| Database | Tipo | Escala | Melhor Para |
|---|---|---|---|
pgvector | ExtensãoOSS | ~10M | PostgreSQL existente |
Pinecone | ManagedManaged | Billions | Zero-ops, Escala rápida |
Qdrant | OSSOSS | ~100M | Performance, Filtering |
Weaviate | OSSOSS | ~100M | GraphQL, Módulos ML |
Milvus | OSSOSS | Billions | Big Data, GPU accel |
Chroma | OSSOSS | ~1M | Prototipagem, Dev local |
Modelos de Embedding (2025)
| Modelo | Dim | Tipo | MTEB |
|---|---|---|---|
text-embedding-3-large | 3072 | APIAPI | 64.6 |
Cohere embed-v3 | 1024 | APIAPI | 64.5 |
voyage-3NEW | 1024 | APIAPI | 67.1 |
E5-mistral-7b | 4096 | OSSOSS | 66.6 |
Algoritmos de Indexação
| Estratégia | Tamanho | Quando Usar |
|---|---|---|
Fixed-size | 512-1024 tokens | MVP, docs homogêneos |
Recursive | 500-1500 chars | Texto estruturado |
Semantic | Variável | Docs complexos |
Late ChunkingNEW | Variável | Melhor contexto (Jina) |
Parent-Child | 2000 / 400 | Docs longos |
A tabela acima resume as estratégias, mas esconde o que importa: chunking não é parâmetro de configuração, é a decisão que determina o teto de qualidade do sistema inteiro. Nenhum reranker recupera informação que o chunking destruiu na ingestão. Se você partir um contrato no meio de uma cláusula, a resposta certa deixa de existir no índice — e o modelo vai alucinar em cima do pedaço que sobrou, com toda a confiança do mundo.
O erro mais comum é começar por onde todo tutorial começa: partir o texto a cada N caracteres. Funciona na demo porque a demo usa um artigo de blog bem comportado. Quebra no primeiro documento real.
# Ingenuo: corta a cada 500 caracteres, ignorando estrutura
def chunk_ingenuo(texto: str, tamanho: int = 500) -> list[str]:
return [texto[i:i + tamanho] for i in range(0, len(texto), tamanho)]
contrato = """
Clausula 7.2 - Do inadimplemento
O atraso no pagamento implica multa de 2% ao mes sobre o valor
devido, limitada ao teto de 10% do contrato, e apenas apos o
decimo dia util de atraso.
"""
# chunk 1: "...implica multa de 2% ao mes sobre o valor devido, limi"
# chunk 2: "tada ao teto de 10% do contrato, e apenas apos o decimo..."Repare no que acontece com multa de 2% ao mês: o valor fica no chunk 1 e a condição que o limita fica no chunk 2. Recuperar qualquer um isolado produz resposta errada — e plausível, que é pior.
A correção não é aumentar o chunk — isso empurra o problema para o próximo documento e dilui a relevância do embedding, porque um vetor que representa 2.000 tokens de assuntos diferentes não representa nenhum deles bem. A correção é cortar onde o documento já se divide: parágrafo, cláusula, seção. Você respeita a estrutura que o autor criou e só cai no corte cego quando não há alternativa.
SEPARADORES = ["\n## ", "\n### ", "\n\n", "\n", ". ", " "]
def chunk_recursivo(texto: str, alvo: int = 800, overlap: int = 120) -> list[str]:
"""Corta no separador mais estrutural que couber no alvo.
Desce na hierarquia so quando o trecho ainda nao cabe: primeiro
titulo, depois paragrafo, depois frase, e so entao corte cego.
"""
if len(texto) <= alvo:
return [texto]
for sep in SEPARADORES:
if sep not in texto:
continue
partes, atual = [], ""
for pedaco in texto.split(sep):
if len(atual) + len(pedaco) + len(sep) <= alvo:
atual += (sep if atual else "") + pedaco
else:
if atual:
partes.append(atual)
# carrega o rabo do anterior para nao perder a costura
atual = (atual[-overlap:] + sep + pedaco) if atual else pedaco
if atual:
partes.append(atual)
if all(len(p) <= alvo * 1.3 for p in partes):
return partes
# nenhum separador resolveu: corte cego como ultimo recurso
return [texto[i:i + alvo] for i in range(0, len(texto), alvo - overlap)]O overlap de 10 a 20% existe para o caso em que a informação cai exatamente na fronteira. Custa armazenamento e um pouco de ruído no retrieval — é troca consciente, não número mágico.
Ainda assim, um chunk isolado perde o contexto de onde veio. "O prazo é de 30 dias" não diz prazo de quê. É o que contextual retrieval resolve: antes de gerar o embedding, você prefixa cada chunk com uma frase curta que o situa. Custa uma chamada barata de LLM por chunk na ingestão — uma vez, offline — e paga em toda consulta seguinte.
PROMPT = """Documento: {titulo}
Trecho: {chunk}
Escreva UMA frase curta situando este trecho no documento.
Nao repita o conteudo do trecho."""
def contextualizar(chunk: str, titulo: str, llm) -> str:
contexto = llm.complete(PROMPT.format(titulo=titulo, chunk=chunk))
return f"{contexto.strip()}\n\n{chunk}"
# antes: "O prazo e de 30 dias contados da notificacao."
# depois: "Trecho da clausula 9 do contrato de prestacao de servicos,
# sobre rescisao por parte do contratante.
#
# O prazo e de 30 dias contados da notificacao."O contexto entra no texto embeddado, não no que é exibido. O objetivo é melhorar a busca, não poluir a resposta.
Leitura complementar
Para entender RAG além do pipeline técnico, e de onde a técnica veio, escrevi uma sequência de três textos que parte do Information Retrieval clássico até chegar em Agentic RAG.
Multi-Modal RAG estende o RAG tradicional para processar e recuperar informações de múltiplas modalidades: texto, imagens, áudio, vídeo e documentos estruturados (PDFs, planilhas, diagramas).
| Modelo | Modalidades | Use Case |
|---|---|---|
SigLIPOSS | Imagem + Texto | Busca visual, classificação |
ImageBindOSS | 6 modalidades | Unified embedding space |
Colpali/ColQwen2NEW | Documento visual | RAG em PDFs complexos |
Gemini 2.0API | Multi-modal nativo | Integração GCP |
Agentes são sistemas que usam LLMs para raciocinar, planejar e executar ações, utilizando ferramentas (tools) e memória para completar tarefas complexas.
| Pattern | Descrição | Quando Usar |
|---|---|---|
ReAct | Reason + Act em loop | Tool calling simples |
Plan-and-Execute | Plano > Execução sequencial | Tarefas multi-step |
Supervisor | Coordena múltiplos agentes | Workflows complexos |
Reflexion | Auto-avaliação e correção | Código, alta precisão |
LATS | Tree search + reflection | Problemas complexos |
Vantagens
Limitações
Até pouco tempo atrás, conectar um agente a uma ferramenta externa significava escrever um wrapper específico para cada integração. Dois protocolos abertos resolveram isso de formas diferentes, e é comum confundir um com o outro porque ambos têm agent no nome.
MCP (Model Context Protocol) padroniza a conexão entre um agente e uma ferramenta ou fonte de dado. Em vez de código de integração específico para cada API, banco ou serviço, o agente conversa com um servidor MCP que expõe essas capacidades de forma uniforme. Um mesmo servidor MCP de banco de dados funciona com qualquer agente que fale o protocolo, independente do framework por trás.
A2A (Agent-to-Agent) resolve outro problema: como dois agentes construídos em frameworks distintos conversam entre si. Um agente em LangGraph delegando subtarefa para um agente em CrewAI, sem que nenhum conheça a implementação interna do outro.
| Protocolo | Conecta | Problema que resolve |
|---|---|---|
MCP | Agente ↔ ferramenta ou fonte de dado | Elimina wrapper de integração por ferramenta |
A2A | Agente ↔ agente | Interoperabilidade entre frameworks diferentes |
Leitura complementar
As limitações acima não são teóricas. A maior parte dos times chega rápido a um protótipo funcional, e é na hora de colocar em produção que os problemas aparecem.
Vibe coding é escrever código deixando o agente decidir a maior parte da implementação a partir de instrução solta, aceitando o resultado sem revisão estruturada e iterando por tentativa até parecer funcionar. Funciona para prototipagem e script descartável. Não escala para sistema que precisa ser mantido, revisado por outra pessoa ou auditado.
Desenvolvimento assistido com engenharia difere em três pontos: existe especificação antes do código, existe revisão contra critério definido, e existe rastreabilidade de por que cada decisão foi tomada — o mesmo princípio que já vale para decisão de arquitetura em geral.
| Dimensão | Vibe Coding | Com Engenharia |
|---|---|---|
| Ponto de partida | Instrução solta, conversacional | Especificação escrita |
| Critério de aceite | Parece funcionar | Teste e critério definidos antes |
| Revisão | Superficial ou ausente | Estruturada, contra a especificação |
| Rastreabilidade | Baixa, difícil reconstruir o porquê | Alta, decisão documentada |
| Onde funciona | Protótipo, script descartável | Produção, código mantido por equipe |
Harness é a infraestrutura que envolve o modelo e determina como o agente age no mundo: o loop de execução que decide quando parar e continuar, o sistema de permissão que define o que roda sem aprovação, o sandbox que isola execução de código arbitrário, e a camada que decide o que entra e sai da janela de contexto ao longo de uma tarefa longa.
É comum atribuir o comportamento de um agente inteiramente ao modelo, mas na prática o harness pesa tanto quanto ou mais. Dois agentes com o mesmo modelo e harness diferente produzem confiabilidade bem distinta, porque um harness bom decide corretamente quando parar para confirmar, quando reverter ação malsucedida, e quando o contexto acumulado precisa ser resumido sem perder informação crítica.
Prompt engineering trata de como formular uma instrução isolada. Context engineering trata de um problema mais amplo: o que compõe a janela de contexto ao longo de uma tarefa com dezenas de passos, chamadas de ferramenta e resultado intermediário.
Numa sessão longa o contexto acumula histórico de ação, resultado de ferramenta, arquivo lido e erro corrigido. Manter tudo estoura a janela ou infla o custo por chamada. Descartar sem critério faz o agente perder informação relevante para a próxima decisão. A disciplina é decidir isso de forma sistemática.
Escrever, antes do código, uma descrição estruturada do que precisa ser construído — precisa o suficiente para um agente executar com fidelidade e para um humano revisar o resultado contra ela depois.
Não é requisito tradicional reaproveitado. Uma especificação boa para agente precisa ser explícita sobre o que instrução informal deixa implícito: contrato de entrada e saída, casos de borda, o que está fora de escopo, e critério de aceite verificável.
Objetivo: validar CPF recebido no cadastro de cliente Contrato: entrada: string saida: booleano + mensagem de erro quando invalido Casos de borda: CPF com formatacao (pontos e traco) deve ser aceito CPF so com zeros deve ser rejeitado CPF com digito verificador incorreto deve ser rejeitado Fora de escopo: Verificacao de CPF ativo na Receita Federal Criterio de aceite: Passa nos 12 casos de cpf_test_cases.json
AGENTS.md é a convenção de documentar, num arquivo na raiz do projeto, o contexto que um agente precisa para operar naquele repositório: convenção de código, comando de build e teste, estrutura de pastas, e restrição que não fica óbvia só lendo o código.
Agent Skills empacota um procedimento reutilizável — instruções e às vezes ferramentas próprias — que o agente consulta sob demanda, em vez de carregar tudo na instrução inicial de toda tarefa.
| AGENTS.md | Agent Skills | |
|---|---|---|
| Natureza | Contexto permanente do projeto | Conhecimento sob demanda |
| Quando carrega | Sempre relevante | Só quando a tarefa pede |
| Custo de contexto | Fixo em toda tarefa | Pago apenas no uso |
Avaliar código gerado por agente exige critério além de compilou ou passou no teste escrito às pressas depois. Dois eixos importam.
Leitura complementar
Escrevi sobre a fronteira entre experimentação e engenharia, e sobre o que aprendi abrindo o capô dos agentes de codificação.
Em sistemas enterprise, certas ações são irreversíveis ou de alto risco. HITL permite que humanos revisem e aprovem antes da execução.
| Pattern | Descrição | Use Case |
|---|---|---|
Synchronous | Bloqueia até aprovação | Chat assistido |
Asynchronous | Checkpoint + notificação | Workflows batch |
Escalation | Threshold-based routing | Suporte tiered |
Audit Trail | Log para review posterior | Compliance |
interrupt_before=["request_approval"] no compile() para pausar o grafo e aguardar aprovação humana via aupdate_state().Input Threats
Output Threats
Exemplo de guardrail robusto com scoring, logging e múltiplos patterns:
import re
import logging
from enum import Enum
from dataclasses import dataclass
from typing import Optional
logger = logging.getLogger(__name__)
class GuardAction(Enum):
ALLOW = "allow"
BLOCK = "block"
FLAG = "flag" # permite mas marca para review
@dataclass
class GuardResult:
action: GuardAction
reason: Optional[str] = None
risk_score: float = 0.0
class PromptInjectionGuard:
"""Production-grade prompt injection detection."""
HIGH_RISK_PATTERNS = [
(r"ignore\s+(all\s+)?(previous|prior)\s+instructions?", 1.0),
(r"you\s+are\s+now\s+(in\s+)?\w+\s*mode", 0.9),
(r"pretend\s+(you\s+are|to\s+be)", 0.8),
(r"disregard\s+(everything|all)", 0.95),
(r"<\/?(system|user|assistant)>", 0.9), # XML injection
]
def __init__(self, block_threshold: float = 0.8):
self.block_threshold = block_threshold
async def check(self, content: str) -> GuardResult:
normalized = content.lower().strip()
max_score = 0.0
for pattern, score in self.HIGH_RISK_PATTERNS:
if re.search(pattern, normalized, re.IGNORECASE):
max_score = max(max_score, score)
if max_score >= self.block_threshold:
logger.warning(f"Blocked injection attempt, score: {max_score}")
return GuardResult(GuardAction.BLOCK, "Injection detected", max_score)
return GuardResult(GuardAction.ALLOW, risk_score=max_score)Leitura complementar
O guard acima cobre detecção de injection, mas guardrail de verdade precisa continuar funcionando mesmo quando o modelo por trás falha ou muda de comportamento.
A LGPD impacta diretamente sistemas GenAI que processam dados pessoais de brasileiros, incluindo embeddings e RAG.
Requisitos Chave
Impacto em RAG
Regulamentação europeia classifica sistemas de IA por risco e exige conformidade progressiva. Em vigor desde Agosto 2024.
Classificação de Risco
| Nível | Exemplo GenAI | Requisitos |
|---|---|---|
InaceitávelPROIBIDO | Social scoring, manipulação | Proibido |
Alto RiscoALTO | RH, crédito, saúde | Registro, auditoria |
TransparênciaMÉDIO | Chatbots, deepfakes | Disclosure obrigatório |
MínimoBAIXO | Recomendações, busca | Boas práticas |
Dados & Privacidade
Transparência & Audit
Segurança & Controle
Arquitetura assíncrona para sistemas GenAI em produção com alta disponibilidade.
Leitura complementar
Esta seção existe porque protótipo e produção são coisas estruturalmente diferentes, não uma versão mais robusta da mesma coisa.
| Componente | % do Custo | Otimização |
|---|---|---|
LLM Inference | 40-60% | Caching, routing, prompts menores |
Embeddings | 15-25% | Batch, cache, modelos menores |
Vector DB | 10-20% | Compressão, tiering |
Compute/GPU | 10-15% | Spot instances, auto-scaling |
Cache baseado em similaridade semântica, não apenas match exato. Queries similares retornam respostas cacheadas.
Ferramentas
Roteia queries para o modelo mais custo-eficienteque consegue resolvê-las com qualidade adequada.
Leitura complementar
Custo de LLM em produção só se controla se você mede direito. Reuni os indicadores que uso para acompanhar saúde e custo de sistemas de IA.
Data Lineage rastreia a origem, transformação e uso de cada dado no sistema. Em GenAI, isso significa saber exatamente de onde veio cada chunk, como foi processado e onde foi usado.
Integração com Observability
| Tier | RTO | RPO |
|---|---|---|
Tier 1 - Critical | <15 min | ~0 (sync) |
Tier 2 - High | <1 hora | <15 min |
Tier 3 - Medium | <4 horas | <1 hora |
O que fazer backup
Estratégias por Componente
LLM Provider Down
Vector DB Down
Full Disaster
| Aspecto | RAG | Fine-tuning |
|---|---|---|
Custo Inicial | BaixoWIN | Alto |
Atualização | Tempo realWIN | Re-treino |
Privacidade | AltaWIN | Dados no modelo |
Auditabilidade | CitaçõesWIN | Black box |
Estilo/Tom | Limitado | PersonalizadoWIN |
Raciocínio | Context-dependent | InternalizadoWIN |
| Cenário | Arquitetura Recomendada |
|---|---|
FAQ / Suporte básico | RAG simples + Guardrails |
Análise de documentos | RAG + Multi-Modal |
Automação de tarefas | Agents + HITL |
Copilot interno | RAG + Agents + Memory |
Aplicação crítica | Full stack + DR + Compliance |
Core
Segurança
Observabilidade
Resiliência