Guia de Arquitetura GenAI

    Padrões, ferramentas e melhores práticas para construir sistemas de IA Generativa em produção. Um guia completo para arquitetos e engenheiros.

    1📖Introdução à Arquitetura GenAI

    Fundamentos, importância e taxonomia de aplicações
    O que você vai aprender: Esta seção apresenta os conceitos fundamentais de IA Generativa (GenAI) e por que uma arquitetura bem planejada é essencial. Você entenderá a diferença entre chatbots simples e sistemas de produção, os tipos de aplicações GenAI (assistentes, RAG, agentes) e os pilares que sustentam um projeto enterprise-ready. Ideal para quem está começando ou quer alinhar conceitos com a equipe.

    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.

    Retrieval
    Busca semântica
    Generation
    LLM Response
    Orchestration
    Agentes & Chains

    POR QUE IMPORTA?

    Redução de Alucinações
    RAG ancora respostas em dados reais, aumentando confiabilidade de 40% para 90%+
    • Dados Atualizados: Acesso a informações além do training cutoff
    • Privacidade: Dados sensíveis sem fine-tuning
    • Auditabilidade: Rastreamento de fontes e decisões
    • Escalabilidade: Arquitetura modular e extensível
    • Custo-Eficiência: RAG vs Fine-tuning = 10x mais barato
    90%+
    Precisão com RAG
    <2s
    Latência Target

    TAXONOMIA DE APLICAÇÕES

    Sweet Spot Enterprise
    Copilots com RAG representam o melhor equilíbrio entre capacidade e controle para produção.

    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.

    2🗃Stack Tecnológico

    Modelos LLM, frameworks e ferramentas para produção
    O que você vai aprender: panorama das tecnologias disponíveis hoje para construir sistemas GenAI. Comparativo dos principais LLMs, frameworks de orquestração — incluindo os protocolos de agente que ganharam tração nos últimos meses — plataformas de observabilidade e vector databases. Esta seção existe para ajudar a tomar decisão informada sobre qual ferramenta adotar, não para promover fornecedor.

    MODELOS LLM

    Provedores API · atualizado em ago/2026

    ModeloContextoForçaProvedor
    Claude Opus 4.8SOTA
    200KEstado da arte em código e raciocínio longoAnthropic
    Claude Sonnet 5API
    200KEquilíbrio custo-performanceAnthropic
    Claude Haiku 4.5API
    200KAlto volume, baixo custoAnthropic
    GPT-5.4 / 5.5API
    até 1MRaciocínio, uso de computador, fluxos agênticosOpenAI
    Gemini 3.1 ProAPI
    1MMultimodal, raciocínio profundoGoogle
    Gemini 3.5 FlashAPI
    1MCoding agêntico, custo-benefícioGoogle

    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)

    ModeloParamsCaso de Uso
    LlamaOSS
    famíliaControle total, fine-tuning, edge
    QwenOSS
    famíliaMultilingual, coding
    MixtralOSS
    MoECusto-benefício em self-hosting
    DeepSeekOSS
    famíliaRaciocínio, custo baixo

    FRAMEWORKS & FERRAMENTAS

    Orquestração

    • LangChain: RAG, chains simples
    • LangGraph: Agents, workflows complexos, estado explícito
    • LlamaIndex: RAG avançado, indexação
    • CrewAI: Multi-agent simplificado
    • ADK: Agent Development Kit, com suporte nativo a A2A
    • Agno: Orquestração leve, baixo overhead em produção
    • DSPy: Otimização de prompts
    • Semantic Kernel: Enterprise (Microsoft)

    Protocolos de Agente

    • MCP: Model Context Protocol — conecta agente a ferramenta e fonte de dado
    • A2A: Agent-to-Agent — conecta agente a agente entre frameworks distintos

    Model Serving

    • vLLM: Alta performance, PagedAttention
    • TGI: HuggingFace, Production-ready
    • Ollama: Dev local, simplicidade
    • TensorRT-LLM: NVIDIA optimized

    Observabilidade & LLMOps

    LangSmithLangFusePrometheusGrafanaOpenTelemetryHeliconePortkey

    Guardrails & Segurança

    NeMo GuardrailsGuardrails AILLM GuardLakera

    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.

    3🔍RAG (Retrieval-Augmented Generation)

    Pipeline completo, Vector Databases e estratégias avançadas
    O que você vai aprender: RAG é a técnica que permite LLMs responderem com base em seus próprios documentos, eliminando alucinações e mantendo informações atualizadas. Você aprenderá o pipeline completo (ingestão, chunking, embedding, retrieval, geração), como escolher vector databases e técnicas avançadas como Hybrid Search, Reranking e Contextual Retrieval. Essencial para quem quer construir assistentes baseados em documentos corporativos.

    O QUE É RAG?

    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

    Retrieval
    Buscar info certa
    Augment
    Inserir no prompt
    Ground
    Ancorar resposta

    VANTAGENS & LIMITAÇÕES

    Vantagens

    • Informação atualizada em tempo real
    • Redução drástica de alucinações
    • Privacidade: dados sem fine-tuning
    • Custo menor que treinamento
    • Auditabilidade (citação de fontes)

    Limitações

    • Dependente da qualidade da busca
    • Requer infra de Vector DB
    • Chunking afeta qualidade
    • Latência adicional (~100-500ms)

    Casos de Uso Ideais

    Chatbots de SuporteAnálise JurídicaDocumentação InternaQ&A sobre PDFs
    Dica Pro
    Use instrução "Se não encontrar no contexto, diga 'Não sei'" para evitar alucinações.

    VECTOR DATABASES

    DatabaseTipoEscalaMelhor Para
    pgvector
    ExtensãoOSS
    ~10MPostgreSQL existente
    Pinecone
    ManagedManaged
    BillionsZero-ops, Escala rápida
    Qdrant
    OSSOSS
    ~100MPerformance, Filtering
    Weaviate
    OSSOSS
    ~100MGraphQL, Módulos ML
    Milvus
    OSSOSS
    BillionsBig Data, GPU accel
    Chroma
    OSSOSS
    ~1MPrototipagem, Dev local
    Recomendação por Cenário
    Startup: Pinecone | Enterprise + Compliance: pgvector | Alta Escala: Milvus

    EMBEDDINGS & INDEXAÇÃO

    Modelos de Embedding (2025)

    ModeloDimTipoMTEB
    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

    • FLAT: 100% recall, O(n)
    • IVF: 95-99%, O(sqrt(n))
    • HNSW: 95-99%, O(log n)
    • PQ: Compressão, memória baixa
    • IVF-PQ: >100M vetores
    • ScaNN: Google optimized

    ESTRATÉGIAS DE CHUNKING

    EstratégiaTamanhoQuando Usar
    Fixed-size
    512-1024 tokensMVP, docs homogêneos
    Recursive
    500-1500 charsTexto estruturado
    Semantic
    VariávelDocs complexos
    Late ChunkingNEW
    VariávelMelhor contexto (Jina)
    Parent-Child
    2000 / 400Docs longos

    TÉCNICAS AVANÇADAS

    Hybrid Search (Semantic + BM25)+
    Combina busca semântica (vetores) com keyword matching (BM25) usando Reciprocal Rank Fusion.
    Resultado
    Melhora recall em 15-25% comparado a busca semântica pura.
    HyDE (Hypothetical Document Embeddings)+
    Gera um documento hipotético que responderia à query, usa o embedding dele para busca. Útil quando queries são muito diferentes dos documentos.
    Contextual Retrieval (Anthropic)+
    Adiciona contexto explicativo a cada chunk antes do embedding. Reduz falhas de retrieval em até 49%.
    Graph RAG (Microsoft)+
    Combina Knowledge Graphs com RAG para capturar relações entre entidades. Ideal para queries que requerem raciocínio sobre conexões.
    Agentic RAG / Self-RAG+
    O agente decide dinamicamente se precisa buscar, qual fonte usar, e avalia qualidade dos resultados. Auto-reflexão sobre documentos recuperados.

    CHUNKING NA PRÁTICA: A DECISÃO QUE DEFINE A QUALIDADE DO SEU RAG

    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.

    O ponto de partida de quase todo projeto — e o motivo de tantos RAGs responderem bem em teste e mal em produção:
    python
    # 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.

    Corte que respeita a hierarquia do documento, com overlap para não perder a costura entre chunks:
    python
    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.

    O chunk vai para o índice carregando a própria localização:
    python
    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.

    Como decidir, na prática
    Comece medindo, não escolhendo. Monte 30 a 50 perguntas reais com resposta conhecida, rode a ingestão com duas estratégias e compare recall@10: em quantas o trecho certo apareceu entre os dez primeiros? Recall baixo significa problema de chunking ou embedding — reranker não resolve, porque só reordena o que o retrieval já trouxe. Recall alto com resposta errada aponta para reranking ou para o prompt de geração.

    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.

    4🖼Multi-Modal RAG

    Processamento de imagens, áudio, vídeo e documentos complexos com IA Generativa
    O que você vai aprender: Multi-Modal RAG permite buscar e processar imagens, áudios, vídeos e documentos escaneados usando modelos como SigLIP, ImageBind e ColQwen2. Você aprenderá a construir um pipeline unificado que entende múltiplas modalidades e como isso é crucial para empresas com bases de conhecimento ricas em conteúdo visual.

    O QUE É MULTI-MODAL 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).

    Use Cases Enterprise
    Análise de contratos com assinaturas escaneadas, manuais técnicos com diagramas, call centers com transcrição de áudio, compliance com análise de vídeo.

    MODELOS DE EMBEDDING MULTI-MODAL

    ModeloModalidadesUse Case
    SigLIPOSS
    Imagem + TextoBusca visual, classificação
    ImageBindOSS
    6 modalidadesUnified embedding space
    Colpali/ColQwen2NEW
    Documento visualRAG em PDFs complexos
    Gemini 2.0API
    Multi-modal nativoIntegração GCP

    ARQUITETURA MULTI-MODAL

    5🤖Agents & LangGraph

    Arquitetura de agentes, patterns e memória
    O que você vai aprender: Agentes de IA são sistemas que podem planejar, usar ferramentas e tomar decisões autonomamente. Esta seção aborda os padrões arquiteturais ReAct e Plan-and-Execute, como usar LangGraph para orquestrar fluxos complexos, e os tipos de memória (curto prazo, longo prazo, semântica) necessários para agentes em produção.

    ARQUITETURA DE AGENTES

    Agentes são sistemas que usam LLMs para raciocinar, planejar e executar ações, utilizando ferramentas (tools) e memória para completar tarefas complexas.

    Reasoning
    Decide próxima ação
    Tool Use
    Executa ferramentas
    Memory
    Mantém contexto

    PATTERNS DE AGENTES

    PatternDescriçãoQuando Usar
    ReAct
    Reason + Act em loopTool calling simples
    Plan-and-Execute
    Plano > Execução sequencialTarefas multi-step
    Supervisor
    Coordena múltiplos agentesWorkflows complexos
    Reflexion
    Auto-avaliação e correçãoCódigo, alta precisão
    LATS
    Tree search + reflectionProblemas complexos

    Vantagens

    • Tarefas complexas automatizadas
    • Auto-correção de erros
    • Integração com sistemas

    Limitações

    • Custo elevado (múltiplas chamadas)
    • Latência alta (5-60s)
    • Requer guardrails robustos

    TIPOS DE MEMÓRIA PARA AGENTES

    Working Memory
    Context window atual (4K-200K tokens)
    Episodic Memory
    Histórico de conversas em Vector DB
    Semantic Memory
    Knowledge base persistente (RAG)
    Procedural Memory
    Tools e skills aprendidas

    PROTOCOLOS DE AGENTE: MCP E A2A

    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.

    ProtocoloConectaProblema que resolve
    MCP
    Agente ↔ ferramenta ou fonte de dadoElimina wrapper de integração por ferramenta
    A2A
    Agente ↔ agenteInteroperabilidade entre frameworks diferentes
    Dica pro
    Os dois não competem, se complementam. Um sistema multiagente maduro usa MCP para cada agente acessar suas ferramentas, e A2A para os agentes se comunicarem na camada de orquestração.
    Regra de ouro
    Se o problema é “meu agente precisa acessar esse sistema externo”, pense em MCP. Se é “esses dois agentes precisam trabalhar juntos”, pense em A2A. Misturar os dois na mesma decisão é o erro mais comum de quem está aprendendo os protocolos agora.

    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.

    6👤Engenharia de Agentes de Codificação

    Da experimentação ao harness, especificação e avaliação de código gerado por agente
    O que você vai aprender: agentes que escrevem e executam código são uma categoria própria dentro de sistemas GenAI, com problemas que não aparecem em copilot de atendimento ou pipeline de RAG. Esta seção cobre a diferença entre vibe coding e engenharia de verdade, o que sustenta um agente por baixo do modelo, como gerenciar contexto numa sessão longa, como escrever especificação que um agente executa com fidelidade, e como avaliar o resultado.

    VIBE CODING x DESENVOLVIMENTO ASSISTIDO POR IA

    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ãoVibe CodingCom Engenharia
    Ponto de partidaInstrução solta, conversacionalEspecificação escrita
    Critério de aceiteParece funcionarTeste e critério definidos antes
    RevisãoSuperficial ou ausenteEstruturada, contra a especificação
    RastreabilidadeBaixa, difícil reconstruir o porquêAlta, decisão documentada
    Onde funcionaProtótipo, script descartávelProdução, código mantido por equipe

    AGENT HARNESS

    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.

    • Loop de execução Sequência ação, observação, próxima ação — e quando considerar a tarefa concluída.
    • Sistema de permissão O que executa livre, o que exige confirmação, o que é proibido. Escrita em arquivo e execução de rede não são a mesma coisa.
    • Sandbox Isola a execução do ambiente real, para que ação incorreta não tenha efeito irreversível fora do escopo.
    • Gestão de contexto Decide o que permanece, o que é resumido e o que é descartado conforme o histórico cresce.
    Regra de ouro
    Antes de avaliar se um agente é bom, avalie o harness em que ele roda. Modelo de ponta com harness sem controle de permissão claro é mais arriscado que modelo intermediário com harness bem desenhado.

    CONTEXT ENGINEERING

    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.

    • Sumarização progressiva Resumir passos concluídos que não precisam mais do detalhe original, mantendo só a conclusão.
    • Recuperação sob demanda Em vez de manter todo arquivo lido na janela, indexar e buscar de volta quando necessário — RAG dentro do próprio fluxo do agente.
    • Particionamento por subtarefa Delegar parte do trabalho a uma execução com contexto isolado, devolvendo só o resultado relevante.
    Dica pro
    Trate o orçamento de contexto como recurso finito desde o desenho do agente, não como algo a resolver quando a janela já estourou em produção. Definir política de sumarização depois que o sistema está em uso costuma custar mais retrabalho do que planejar no início.

    SPEC-DRIVEN DEVELOPMENT

    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
    Regra de ouro
    Uma especificação que o agente executa sem perguntas de esclarecimento é uma especificação completa. Se ele precisa perguntar o que fazer num caso de borda, o buraco estava na especificação — não no agente.

    AGENTS.MD E AGENT SKILLS

    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.mdAgent Skills
    NaturezaContexto permanente do projetoConhecimento sob demanda
    Quando carregaSempre relevanteSó quando a tarefa pede
    Custo de contextoFixo em toda tarefaPago apenas no uso
    Recomendação
    Comece por AGENTS.md em qualquer projeto onde um agente opere de forma recorrente. Migre para Skills quando notar que partes do arquivo só valem para um subconjunto de tarefas — esse é o sinal de que aquele bloco deveria ser uma skill separada, em vez de inflar o contexto permanente.

    AVALIAÇÃO E RED TEAMING

    Avaliar código gerado por agente exige critério além de compilou ou passou no teste escrito às pressas depois. Dois eixos importam.

    • Correção O código atende à especificação, incluindo os casos de borda explicitados nela — não só o caminho feliz.
    • Robustez contra fuga de escopo Teste deliberado de cenário em que o agente, sob ambiguidade, produz algo fora do escopo: implementa função não pedida porque pareceu fazer sentido, ou ignora restrição declarada.

    Leitura complementar

    Escrevi sobre a fronteira entre experimentação e engenharia, e sobre o que aprendi abrindo o capô dos agentes de codificação.

    6👤Human-in-the-Loop (HITL)

    Padrões de interrupção, aprovação e supervisão humana em sistemas de agentes
    O que você vai aprender: Human-in-the-Loop é o padrão que permite pausar a execução e aguardar aprovação humana. Quando usar HITL: pagamentos, envio de emails, deleções. Patterns: síncrono, assíncrono, escalation. Implementação com LangGraph usando checkpoints.

    POR QUE HUMAN-IN-THE-LOOP?

    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.

    Financeiro
    Pagamentos, transferências
    Comunicação
    Emails externos, contratos
    Destrutivo
    Deletar, modificar críticos

    PATTERNS DE HITL

    PatternDescriçãoUse Case
    Synchronous
    Bloqueia até aprovaçãoChat assistido
    Asynchronous
    Checkpoint + notificaçãoWorkflows batch
    Escalation
    Threshold-based routingSuporte tiered
    Audit Trail
    Log para review posteriorCompliance

    ARQUITETURA HITL COM LANGGRAPH

    AGENT NODE
    ReasoningTool Selection
    RISK CLASSIFIER
    Action TypeRisk Score
    CHECKPOINT
    State PersistNotification
    EXECUTION
    Tool InvokeResult Log
    LangGraph interrupt_before
    Use interrupt_before=["request_approval"] no compile() para pausar o grafo e aguardar aprovação humana via aupdate_state().

    7🔒Segurança & Guardrails

    Threat model, proteções e implementação production-ready
    O que você vai aprender: Modelo de ameaças específico para LLMs: Prompt Injection, Jailbreak. Como implementar guardrails de entrada e saída, proteção contra vazamento de dados (PII), e código production-ready para detectar ataques.

    THREAT MODEL GENAI

    Input Threats

    • Prompt Injection: Manipula comportamento do LLM
    • Jailbreaking: Bypass de safety guidelines
    • Data Extraction: Extrai training data
    • Context Manipulation: Injeção via RAG
    • DoS: Queries extremamente longas

    Output Threats

    • Hallucination: Info falsa como fato
    • Data Leakage: Exposição de dados sensíveis
    • Harmful Content: Conteúdo prejudicial
    • PII Exposure: Vazamento de dados pessoais
    • Code Injection: Código malicioso

    CAMADAS DE PROTEÇÃO

    IMPLEMENTAÇÃO PRODUCTION-READY

    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)
    Recomendação
    Em produção, combine regex com classificadores ML (LLM Guard, Lakera) para cobertura completa.

    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.

    8Compliance & Regulamentação

    LGPD, AI Act, SOC2 e frameworks de governança para sistemas GenAI
    O que você vai aprender: LGPD (Brasil) exige controle sobre dados pessoais em embeddings. AI Act (Europa) classifica sistemas de IA por nível de risco. O que é obrigatório implementar: PII detection, audit logs, direito ao esquecimento. Checklist completo de compliance.

    LGPD - LEI GERAL DE PROTEÇÃO DE DADOS

    A LGPD impacta diretamente sistemas GenAI que processam dados pessoais de brasileiros, incluindo embeddings e RAG.

    Requisitos Chave

    • Base Legal: Consentimento ou legítimo interesse documentado
    • Minimização: Processar apenas dados necessários
    • Retenção: Política clara de exclusão
    • Exclusão: Direito ao esquecimento (delete embeddings)

    Impacto em RAG

    • PII em chunks: Detectar e anonimizar antes de embedar
    • Vector deletion: Excluir embeddings de dados removidos
    • Audit trail: Log de todo processamento de dados pessoais

    EU AI ACT

    Regulamentação europeia classifica sistemas de IA por risco e exige conformidade progressiva. Em vigor desde Agosto 2024.

    Classificação de Risco

    NívelExemplo GenAIRequisitos
    InaceitávelPROIBIDO
    Social scoring, manipulaçãoProibido
    Alto RiscoALTO
    RH, crédito, saúdeRegistro, auditoria
    TransparênciaMÉDIO
    Chatbots, deepfakesDisclosure obrigatório
    MínimoBAIXO
    Recomendações, buscaBoas práticas

    CHECKLIST DE COMPLIANCE PARA GENAI

    Dados & Privacidade

    • PII detection implementado
    • Anonimização antes de embeddings
    • Política de retenção definida
    • Processo de exclusão funcional

    Transparência & Audit

    • Disclosure de uso de IA
    • Lineage completo implementado
    • Logs imutáveis (append-only)
    • Explicabilidade das decisões

    Segurança & Controle

    • Encryption at rest e in transit
    • Access control (RBAC)
    • Input/Output guards ativos
    • Incident response plan

    9🏗Padrões de Arquitetura

    Event-driven, resiliência, escalabilidade e observabilidade
    O que você vai aprender: Event-Driven Architecture: processamento assíncrono. Circuit Breaker e Retry com Backoff: resiliência. Métricas específicas para observabilidade de LLMs. Transforma protótipo em sistema production-grade.

    EVENT-DRIVEN GENAI

    Arquitetura assíncrona para sistemas GenAI em produção com alta disponibilidade.

    • Desacoplamento (retry sem bloqueio)
    • Backpressure handling automático
    • Dead Letter Queue para falhas
    • Async processing para long-running tasks

    RESILIENCIA

    Circuit Breaker Config
    • failure_threshold: 5 falhas consecutivas
    • recovery_timeout: 30 segundos
    • half_open_requests: 3 tentativas
    Retry com Exponential Backoff
    • max_retries: 3
    • base_delay: 1s, 2s, 4s
    • jitter: +/- 20%
    Fallback Strategy
    • Primary: Claude Sonnet
    • Fallback 1: GPT-4o-mini
    • Fallback 2: Cached response

    OBSERVABILIDADE PARA LLMS

    Latência P50/P99
    Tempo de resposta do LLM
    Token Usage
    Input/Output tokens por request
    Error Rate
    Taxa de falhas por modelo
    Cost per Request
    Custo médio por chamada

    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.

    10💰Cost Optimization

    Estratégias para reduzir custos de LLM mantendo qualidade em produção
    O que você vai aprender: Chamadas de LLM podem custar caro em escala. Esta seção ensina técnicas para reduzir custos em 40-70% sem perder qualidade: Semantic Caching (evita chamadas repetidas), Model Routing (usa modelos baratos para queries simples), e Prompt Caching nativo (Anthropic/OpenAI). Você também aprenderá a otimizar embeddings e infraestrutura.

    PRINCIPAIS CUSTOS EM GENAI

    Componente% do CustoOtimizaçã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

    SEMANTIC CACHING

    Cache baseado em similaridade semântica, não apenas match exato. Queries similares retornam respostas cacheadas.

    30-60%
    Redução de chamadas LLM
    <50ms
    Latência cache hit

    Ferramentas

    • GPTCache: Open-source, plugável
    • Redis + Vector: Custom implementation
    • Prompt Caching: Anthropic/OpenAI nativo (50-90% economia)

    INTELLIGENT MODEL ROUTING

    Roteia queries para o modelo mais custo-eficienteque consegue resolvê-las com qualidade adequada.

    Query
    ->
    Router LLM
    Classify
    ->
    Simple -> GPT-4o-mini$0.15/1M
    Medium -> Claude Sonnet$3/1M
    Complex -> GPT-4o / Opus$15/1M
    Resultado
    40-70% redução de custos mantendo qualidade. Overhead da classificação: ~$0.001 por query.

    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.

    11🔗Data Lineage & Governance

    Rastreabilidade completa de dados em pipelines RAG e sistemas GenAI
    O que você vai aprender: Quando um LLM dá uma resposta errada, você precisa saber de onde veio aquela informação. Data Lineage rastreia a origem de cada chunk, como foi processado, e onde foi usado. Você conhecerá ferramentas como OpenLineage, DataHub e LangFuse, e como implementar rastreabilidade completa no seu pipeline RAG.

    O QUE É DATA LINEAGE EM GENAI?

    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.

    Pergunta Fundamental
    "Esta resposta veio do documento X, página Y, processado em Z, usando modelo W, com score de confiança N"

    FERRAMENTAS DE LINEAGE

    • OpenLineage: Standard aberto, eventos de lineage
    • DataHub: LinkedIn, metadata platform
    • Apache Atlas: Hadoop ecosystem
    • Marquez: WeWork, OpenLineage-native
    • Atlan: Modern data catalog

    Integração com Observability

    • Trace ID: Propagar em todo request
    • Span tags: chunk_ids, doc_ids
    • LangFuse: Nativamente suporta lineage

    QUERIES ÚTEIS DE LINEAGE

    ?
    Impacto
    "Quais respostas usaram doc X?"
    ?
    Freshness
    "Chunks mais antigos usados"
    ?
    Quality
    "Docs com baixo retrieval score"
    ?
    Coverage
    "% do corpus nunca recuperado"

    12Disaster Recovery & Business Continuity

    Estratégias de backup, failover e recuperação para sistemas GenAI críticos
    O que você vai aprender: O que acontece quando seu vector database cai? Ou quando a API do LLM fica indisponível? Esta seção cobre RTO/RPO (quanto tempo e dados você pode perder), o que fazer backup em sistemas GenAI (embeddings, configs, prompts), estratégias de failover multi-region, e runbooks detalhados para recuperação.

    MÉTRICAS DE DR

    RTO
    Recovery Time Objective
    RPO
    Recovery Point Objective
    TierRTORPO
    Tier 1 - Critical
    <15 min~0 (sync)
    Tier 2 - High
    <1 hora<15 min
    Tier 3 - Medium
    <4 horas<1 hora

    COMPONENTES CRÍTICOS GENAI

    O que fazer backup

    • Vector Store: Embeddings + metadata
    • PostgreSQL: Lineage, configs, users
    • Prompt Templates: Versionados em Git
    • Model Configs: Parâmetros, thresholds
    • Source Documents: S3 com versionamento

    Estratégias por Componente

    • Qdrant/Milvus: Snapshots + replicação
    • pgvector: pg_dump + streaming replication
    • Redis Cache: AOF + RDB, ou reconstruir
    • LLM Provider: Fallback multi-provider

    RUNBOOK DE RECUPERAÇÃO

    LLM Provider Down

    • 1. Detectar via health check
    • 2. Circuit breaker ativa
    • 3. Fallback para provider B
    • 4. Log incident
    • 5. Notificar on-call

    Vector DB Down

    • 1. Failover para replica
    • 2. Se não houver replica: modo degradado
    • 3. Restaurar snapshot mais recente
    • 4. Validar integridade
    • 5. Reabilitar serviço

    Full Disaster

    • 1. Ativar DR site
    • 2. Restaurar PostgreSQL
    • 3. Restaurar Vector DB
    • 4. Validar pipelines
    • 5. DNS failover

    13Comparativo & Checklist

    Resumo executivo e checklist de produção para sistemas GenAI
    O que você vai aprender: Esta seção final consolida todo o guia em um checklist prático para colocar seu sistema GenAI em produção. Inclui comparativo RAG vs Fine-tuning, matriz de decisão para escolha de arquitetura, e o checklist completo de production-readiness.

    RAG VS FINE-TUNING

    AspectoRAGFine-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
    Recomendação
    Use RAG primeiro. Fine-tuning apenas para estilo/tom ou quando RAG não atinge qualidade necessária.

    MATRIZ DE DECISÃO

    CenárioArquitetura 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

    CHECKLIST DE PRODUCTION-READINESS

    Core

    • RAG pipeline funcionando
    • Vector DB com backup
    • Guardrails de entrada/saída
    • Rate limiting implementado

    Segurança

    • Prompt injection protection
    • PII detection/masking
    • Audit logging completo
    • RBAC implementado

    Observabilidade

    • Métricas de latência/custo
    • Tracing distribuído
    • Alertas configurados
    • Dashboard operacional

    Resiliência

    • Circuit breaker
    • Retry com backoff
    • Fallback de provider
    • DR testado

    GenAI Documentação

    Alexsander Valente - 2025