Aula teórico-prática sobre Engenharia de Contexto para LLMs, cobrindo…

INEMA

Engenharia de Contexto na Prática⌗

Conceito⌗

O que é Engenharia de contexto é a prática de organizar, selecionar e injetar as informações certas para um LLM, garantindo respostas úteis, consistentes e alinhadas ao objetivo.

Principais componentes

Instruções fixas (persona, políticas, limites).
Entrada imediata (pergunta do usuário).
Memória de curto prazo (histórico resumido da sessão).
Memória de longo prazo (base de conhecimento externa).
Recuperação inteligente (RAG e busca vetorial).
Orquestração de agentes (pesquisador, sintetizador, validador).
Estrutura de prompt (template claro).
Ciclo de feedback (logs, métricas, ajustes contínuos).

Passo a Passo para Começar⌗

1. Definir objetivo e métrica⌗

Escolher um caso de uso simples (ex.: responder FAQ).
Definir métrica (ex.: % de respostas corretas).

2. Organizar estrutura de projeto⌗

project/ context/ persona.md regras.md formatos.md kb/ ← base de conhecimento prompts/ template.txt logs/ tests/

3. Criar template de prompt⌗

I`nstruções permanentes: {{persona}}

Regras: {{regras}}

Histórico resumido: {{historico_resumido}}

Contexto recuperado: {{trechos_relevantes}}

Pedido do usuário: {{input}}

Formato de saída esperado: {{formatos}} `

4. Implementar memória de curto prazo⌗

Guardar últimos turnos.
Se o histórico crescer, gerar resumos incrementais.

5. Adicionar memória de longo prazo⌗

Se base pequena → busca por palavra-chave.
Se base grande → embeddings + busca vetorial (Supabase, Pinecone, etc.).

6. Orquestrar agentes (quando necessário)⌗

Pesquisador → busca trechos.
Sintetizador → resume.
Validador → garante formato.

7. Montar pipeline (exemplo em n8n)⌗

Webhook → Recuperação → Montagem de prompt → LLM → Pós-processamento → Resposta → Logs.

8. Criar ciclo de feedback⌗

Logar perguntas, trechos usados e respostas.
Avaliar qualidade a cada 20 casos e ajustar kb, chunking ou regras.

Exemplo Prático⌗

Estrutura mínima em Python⌗

fr```om textwrap import dedent

def montar_prompt(persona, regras, historico, trechos, formatos, pergunta): return dedent(f""" Instruções permanentes:

Regras:
{regras}

Histórico resumido:
{historico}

Contexto recuperado:
{trechos}

Pedido do usuário:
{pergunta}

Formato de saída esperado:
{formatos}
""").strip()

Simulação de uso⌗

persona = "Você é um assistente de suporte de uma ONG de pets. Responda de forma clara." regras = "Não invente fatos. Cite a fonte quando usar um trecho." formatos = "Responda em até 5 linhas." historico = "O usuário perguntou antes sobre castração de gatos comunitários." trechos = "- Guia: castração gratuita em mutirões trimestrais; agendamento via formulário." pergunta = "Quais documentos preciso para castrar um gato resgatado ontem?"

print(montar_prompt(persona, regras, historico, trechos, formatos, pergunta))

```### Fluxo visual (Mermaid)

fl```owchart LR A[Input do usuário] --> B[Normalização] B --> C[Memória curta] B --> D[Recuperação RAG] C --> E[Montagem do Prompt] D --> E E --> F[LLM] F --> G[Pós-processamento] G --> H[Resposta ao usuário] G --> I[Logs/Feedback] I --> C I --> D

```---

engenharia de contexto como disciplina prática, podemos decompor em componentes principais (blocos que aparecem em quase todos os sistemas sérios com LLMs).

1. Contexto Fixo (Instruções Permanentes)⌗

O que é: regras, identidade, persona ou política do agente.
Exemplo: “Você é um assistente jurídico que responde com base nas leis brasileiras.”
Função: garante consistência de comportamento.

2. Contexto Dinâmico (Entrada Imediata)⌗

O que é: pergunta do usuário, conversa atual, dados momentâneos.
Exemplo: input do cliente pedindo: “Explique o contrato em linguagem simples.”
Função: ajusta a saída ao caso específico.

3. Memória de Curto Prazo⌗

O que é: histórico da sessão (janela de tokens).
Exemplo: lembrar o que foi dito nos últimos 10 turnos de diálogo.
Função: manter coerência dentro da conversa sem repetir contexto a cada passo.

4. Memória de Longo Prazo⌗

O que é: armazenamento externo (vector DB, Supabase, Pinecone, Redis).
Exemplo: resgatar histórico de atendimentos de um cliente ou conhecimento de um manual técnico.
Função: dar continuidade em múltiplas sessões ou projetos.

5. Recuperação Inteligente (RAG e Indexação)⌗

O que é: busca semântica em bases externas (PDFs, docs, bancos).
Exemplo: usuário pergunta sobre cláusula 12 → o sistema recupera só esse trecho do contrato.
Função: reduzir ruído e focar no dado certo.

6. Orquestração e Especialização (Agentes)⌗

O que é: dividir tarefas entre subagentes ou pipelines.
Exemplo: um agente pesquisa, outro resume, outro valida.
Função: escalar capacidade além de um prompt único.

7. Estrutura de Prompt (Formatação do Contexto)⌗

O que é: como as informações são passadas (templates, JSON, instruções passo a passo).
Exemplo:

Contexto: [trechos do manual] Pergunta: [input do usuário] Regras: [estilo da resposta] * Função: garantir que o modelo processe os dados de forma previsível.

8. Ciclo de Feedback e Avaliação⌗

O que é: métricas, testes A/B, ajustes de contexto.
Exemplo: avaliar se um agente de suporte responde corretamente em 80% dos casos.
Função: evoluir o sistema, não apenas rodar “às cegas”.

Resumo visual da arquitetura⌗

[Instruções fixas] ↓ [Input do usuário] → [Histórico curto prazo] ↓ [Recuperação (RAG)] ↓ [Memória longo prazo] ↓ [Orquestração de agentes] ↓ [Prompt estruturado] ↓ [LLM Output] → [Feedback/Avaliação]

Vamos separar em partes para trazer clareza, pois “engenharia de contexto” está virando um termo da moda e muita gente usa sem entender o que é ou até inflando como hype.

O que é Engenharia de Contexto⌗

Engenharia de contexto é a disciplina (ou prática emergente) de estruturar, organizar e fornecer o contexto adequado para um sistema de IA (principalmente LLMs) de forma que ele produza respostas mais úteis, coerentes e alinhadas ao objetivo. Envolve:

Seleção de informações relevantes Escolher quais dados, instruções, histórico e metadados entram na janela de contexto.
Estruturação do input Como esse contexto é representado: em forma de prompt, tabelas, JSON, embeddings + recuperação RAG, etc.
Orquestração dinâmica Usar agentes, fluxos e arquiteturas (Make, n8n, LangChain, etc.) para injetar contexto certo na hora certa — exemplo: alternar entre memória de curto prazo (Redis), longo prazo (Supabase ou Pinecone) e instruções fixas.
Alinhamento com a intenção Adaptar o contexto ao público ou tarefa: uma resposta técnica, uma narrativa infantil, um relatório corporativo. O contexto guia a "persona" e o comportamento do modelo.
Ciclos de feedback Engenheiros de contexto não apenas escrevem prompts, mas medem, ajustam e otimizam continuamente quais pedaços de contexto elevam a performance.

O que NÃO é Engenharia de Contexto⌗

Não é só “escrever prompts”: prompt engineering é parte, mas engenharia de contexto vai além, incluindo pipelines, memórias, agentes e curadoria.
Não é apenas RAG: RAG é uma técnica dentro da engenharia de contexto.
Não é só naming fancy: colocar “engenharia de contexto” num fluxo simples de copy-paste de instruções não torna isso sofisticado.
Não é substituir programação: ela complementa a engenharia de software, mas não elimina a necessidade de lógica, APIs, infra e testes.

Quanto isso é hype (hiper ou não)⌗

Hype verdadeiro: O termo está sendo inflado como se fosse “a revolução definitiva”. Muita gente apresenta como se tivesse descoberto algo inédito, mas várias práticas já existiam em NLP (pré-processamento, curadoria de dados, feature engineering).
Valor real: Com LLMs, a engenharia de contexto é crucial porque os modelos são “estatísticos” e precisam de framing correto para gerar valor. Empresas que não aplicam isso caem em respostas genéricas e baixo desempenho.
Situação atual: Estamos no início de transformar isso em disciplina séria (papers, padrões, métricas). Por enquanto, ainda é um território misto entre prática artesanal e ciência em construção.

Analogias para fixar⌗

Engenharia de software → organiza código para que o sistema funcione.
Engenharia de contexto → organiza informações para que o modelo “funcione” com inteligência prática.
Sem contexto bem definido, até o melhor modelo parece burro. Com contexto bem trabalhado, até um modelo pequeno parece “esperto”.

versão 2

Engenharia de CONTEXTO