LLM.guide
01 / 26
←→ navegar
✦ Guia Completo 2025

LLMs:
Da Arquitetura
ao Produto

Uma jornada pelo funcionamento interno dos Large Language Models — estratégias, padrões e código real para construir produtos de IA robustos.

TransformerRAGAgentsMCPStreamingGuardrailsToolsMemoryEmbeddingsPrompt Eng.Sub-agentsCacheGroundingReranking
LLM Transformer Prompt Input Output Tokens Context Memory Tools MCP RAG Search Guard rails
01 — Fundamentos

O que é um Large Language Model?

Um LLM é uma rede neural massiva treinada para prever o próximo token dado um contexto. Através de bilhões de parâmetros, aprende padrões de linguagem, raciocínio e conhecimento do mundo.

Escala define capacidade
1T+
Parâmetros
200K+
Tokens Contexto
∞
Casos de uso

Emergência: capacidades como raciocínio, tradução e código surgem sem supervisão direta — apenas da escala e dos dados.

1. Pré-treinamento Trilhões de tokens da internet Objetivo: prever próximo token (self-supervised) Base Model 2. Fine-tuning Supervisionado (SFT) Dados rotulados por humanos Instrução → Resposta ideal Instruct Model 3. RLHF / DPO Feedback humano + reward model Alinhamento com preferências humanas ✦ Modelo Final
02 — Fundamentos

Tokenização & Embeddings

Texto é fragmentado em tokens e cada token é mapeado para um vetor denso em espaço de alta dimensão — onde distância reflete semântica.

Tokenização BPE

"Construindo produto com LLM"

Constru indo ▁produto ▁com ▁LL M

6 tokens · ~1 token ≈ 0.75 palavras em inglês

Analogias no Espaço Vetorial
Rei−Homem+Mulher=Rainha
Paris−França+Alemanha=Berlim
dim_1 (semântica) dim_2 Rei Rainha Príncipe Realeza Paris Berlim Roma Cidades Python Código Tech
03 — Arquitetura

Mecanismo de Atenção

TRANSFORMER BLOCK ×N Input Embeddings + Positional Encoding Multi-Head Attention Q K V Add & LayerNorm Feed-Forward Network Linear → ReLU / GELU → Linear Add & LayerNorm
Fórmula da Atenção

Para cada token, calculamos Query, Key e Value:

Attention(Q,K,V) =
  softmax( Q·Kᵀ / √d_k ) · V
Multi-Head = Múltiplas Perspectivas
Head 1: relações sintáticas
Head 2: correferência
Head N: semântica posicional
Acesso Global ao Contexto

Diferente de RNNs, o Transformer acessa qualquer posição do contexto em O(1) — sem degradação sequencial.

KV Cache

Keys e Values são cacheados durante inferência, evitando recomputação a cada novo token gerado. Fundamental para performance.

04 — Geração de Tokens

Temperatura & Sampling

T = 0.2 — determinístico the a of and to T = 1.0 — balanceado the a of and to T = 2.0 — caótico the a of and to SOFTMAX COM TEMPERATURA P(xᵢ) = exp(zᵢ / T) Σ exp(zⱼ / T) ESTRATÉGIAS Top-K Sampling Top-P / Nucleus Beam Search Greedy Decoding

A temperatura escala os logits antes do softmax, controlando o quanto a distribuição de probabilidade é concentrada ou espalhada.

Quando usar cada valor
T = 0.0Código, SQL, facts
T = 0.7Chat, Q&A, resumo
T = 1.2Brainstorm, poesia
top_p=0.95Melhor geral
config.ts
const params = {
  temperature: 0.7,
  top_p: 0.95,
  max_tokens: 2048,
  stop_sequences: ["###"],
};
05 — Prompt Engineering

Engenharia de Prompts

Prompt engineering é a disciplina de estruturar entradas para maximizar qualidade das saídas. É a camada mais acessível de controle sobre o modelo.

Técnicas Fundamentais
Zero-shot
Instrução direta sem exemplos
Few-shot
2–5 exemplos no prompt → melhor generalização
Chain-of-Thought (CoT)
"Pense passo a passo" → raciocínio explícito
ReAct
Raciocínio + Ação intercalados
Tree-of-Thought (ToT)
Exploração de múltiplos caminhos
Skeleton-of-Thought
Estrutura primeiro, detalha depois
prompt-patterns.ts
// ① Few-shot
const fewShot = `
Texto: "Adorei o produto!"
Classe: POSITIVO

Texto: "Entrega atrasou 3 dias."
Classe: NEGATIVO

Texto: "{{input}}"
Classe:`;

// ② Chain-of-Thought
const cot = `
Resolva: {{problema}}

Pense passo a passo:
1. Dados conhecidos
2. Método de resolução
3. Execute
4. Verifique

Raciocínio:`;

// ③ ReAct pattern
const react = `
Ferramentas: busca_web, calc

Pensamento: [análise]
Ação: ferramenta(params)
Observação: resultado
... repita ...
Resposta Final: conclusão`;
06 — System Prompt

Anatomia do System Prompt

O system prompt define a persona, escopo e restrições do modelo. É a camada de configuração persistente que precede todas as mensagens do usuário.

Anatomia
IDENTIDADE & PAPEL Quem é, o que faz, estilo de comunicação CONHECIMENTO & CONTEXTO Dados da empresa, produto, políticas FORMATO DE RESPOSTA Markdown, JSON, idioma, tamanho GUARDRAILS & RESTRIÇÕES O que não deve fazer, limites de escopo TOOLS & CAPABILITIES Ferramentas disponíveis e quando usá-las
system-prompt.md
## Identidade
Você é Sofia, assistente de suporte da
Acme Corp. Especialista em nossos produtos
SaaS de gestão financeira.

## Tom e Estilo
- Profissional mas amigável
- Respostas concisas (máx. 3 parágrafos)
- Sempre em português do Brasil
- Use exemplos quando relevante

## Conhecimento do Produto
- Starter: até 5 usuários, R$99/mês
- Pro: ilimitado, R$299/mês
- SLA: 99.9% uptime, suporte 24/7

## Restrições
- NÃO discuta concorrentes
- NÃO faça promessas de prazo
- ESCALE para humano se: reembolso,
conta cancelada, dados corrompidos

## Ferramentas
- buscar_conta(email)
- criar_ticket(prioridade, descricao)
- verificar_status_sistema()
07 — Raciocínio

Raciocínio & Reflexão

CHAIN-OF-THOUGHT 1 Problema recebido Decomposição em sub-problemas 2 Raciocínio intermediário Cálculos, inferências, buscas 3 Síntese & verificação Consistência e resposta final o1 / Sonnet Ext. SELF-REFLECTION Modelo avalia sua própria resposta: "A resposta está correta?" "Há contradições?" → Itera até satisfazer critério TREE-OF-THOUGHTS Explora múltiplos caminhos em paralelo Beam search sobre espaço de pensamentos → melhor para problemas combinatórios

Modelos com raciocínio explícito (thinking tokens) produzem uma cadeia interna antes de responder, melhorando dramaticamente performance em tarefas complexas.

reasoning.ts
// Extended thinking (Claude)
const resp = await anthropic
  .messages.create({
    model: 'claude-opus-4-5',
    thinking: {
      type: 'enabled',
      budget_tokens: 10000,
    },
    messages: [{ role: 'user',
      content: complexProblem }],
  });
// [0].type === 'thinking'
// [1].type === 'text'
Quando usar Reasoning
✓Matemática, lógica, código complexo
✓Multi-step research tasks
✓Decisões com trade-offs
✗Chat simples (latência alta)
08 — Contexto

Gerenciamento de Contexto & Threads

O contexto é o recurso mais crítico e limitado. Estratégias inteligentes definem experiência e custo do produto.

Estratégias
Sliding Window
Mantém N últimas mensagens. Simples, perde histórico antigo.
Summarization
Resume mensagens antigas periodicamente. Preserva essência.
Hierarchical Memory
Working → Episodic → Semantic. Recuperação seletiva.
External Store + RAG
Contexto infinito via recuperação vetorial. Estado-da-arte.
CONTEXT WINDOW (200K tokens) SYSTEM PROMPT ~1K tokens cached ✓ TOOL DEFINITIONS ~1.5K tokens CONVERSATION HISTORY 👤 user msg #1 🤖 assistant #1 👤 user msg #2 🤖 assistant #2 ... ~40K tokens ... → sumário das mensagens antigas RAG CONTEXT (retrieved) Chunks relevantes ~8K tokens CURRENT USER INPUT mensagem atual 59% usado 118K/200K
09 — Memória

Memória em Sistemas LLM

🧠
Memória de Trabalho

O próprio context window. Temporária, rápida, cara. Contém a conversa atual e raciocínio em andamento.

📍 In-context
⚡ Imediata
💰 Alto custo
📚
Memória Episódica

Histórico de sessões passadas armazenado externamente. Recuperado por relevância semântica.

🗄️ Vector DB
🔍 Busca semântica
📅 Decay
🌐
Memória Semântica

Conhecimento estruturado sobre o usuário, preferências e fatos. Persiste entre sessões.

👤 User profile
🔑 KV store
♾️ Persistente
memory-manager.ts
class MemoryManager {
  async recall(query: string) {
    // Episodic: last sessions
    const episodes = await
      vectorDB.search(query, 5);
    // Semantic: user profile
    const profile = await
      profileStore.get(userId);
    return { episodes, profile };
  }
}
async save(conv) {
  // Extract key facts via LLM
  const facts = await llm.extract(
    conv, "key_facts_json"
  );
  // Store embedding
  await vectorDB.upsert({
    id: uuid(),
    vector: await embed(facts),
    metadata: { facts, ts: Date.now() }
  });
}
10 — RAG

Retrieval Augmented Generation

RAG conecta LLMs a bases de conhecimento externas, permitindo respostas fundamentadas em dados atualizados sem fine-tuning.

1. Query Pergunta do usuário 2. Embed Query → vetor 3072-d 3. Search ANN top-K pgvector/Pinecone 🗄️ Vector Store 4. Rerank Cross-encoder precisão máxima 5. Augment Injetar chunks no prompt 6. Generate LLM responde com grounding → resposta fundamentada
rag.ts
async function ragQuery(question: string) {
  const qVec = await embed(question);
  const chunks = await vectorDB.query({
    vector: qVec, topK: 20,
  });
  const top5 = await reranker.rerank(
    question, chunks, 5
  );
  return llm.chat(buildPrompt(question, top5));
}
Tipos de RAG
Naive RAGSimples, direto
Advanced RAGReranking, HyDE
Agentic RAGMulti-query, loop
Chunking
Fixed size
Semantic
Recursive
Hierarchical
11 — Retrieval

Embeddings & Reranking

Embeddings convertem texto em vetores. Reranking usa um modelo cross-encoder mais preciso para reordenar os candidatos da busca inicial.

Modelos de Embedding
text-embedding-3-large3072d
voyage-31024d
nomic-embed-text768d
Por que Reranking?
Sem reranking (bi-encoder) 92% 63% 41% Com reranking (cross-encoder) 97% ↑
reranking.ts
// Step 1: Bi-encoder (fast ANN)
const qEmbed = await openai
  .embeddings.create({
    input: query,
    model: 'text-embedding-3-large',
  });

const candidates = await pgvector.query(`
  SELECT id, content,
    1 - (embedding <=> $1) AS score
  FROM documents
  ORDER BY score DESC LIMIT 20
`, [qEmbed]);

// Step 2: Cross-encoder (precise)
const reranked = await cohere.rerank({
  model: 'rerank-english-v3.0',
  query: query,
  documents: candidates.map(c => c.content),
  top_n: 5,
});

// HyDE enhancement (optional)
const hypo = await llm.complete(
  `Resposta hipotética: ${query}`
);
// Search using hypo embedding instead
12 — Tools & MCP

Function Calling & MCP

tools.ts
const tools = [{
  name: 'buscar_produto',
  description: 'Busca produto por nome ou SKU',
  input_schema: {
    type: 'object',
    properties: {
      query: { type: 'string' },
      categoria: { type: 'string' },
    },
    required: ['query'],
  },
}];

// Agentic loop
async function runAgent(input) {
  let messages = [{
    role:'user', content:input
  }];
  while (true) {
    const resp = await llm(messages, tools);
    if (resp.stop_reason === 'end_turn') break;
    const results = await executeTools(
      resp.tool_calls
    );
    messages.push(resp, ...results);
  }
  return resp;
}
MCP — Model Context Protocol

Protocolo aberto da Anthropic para conectar LLMs a ferramentas e dados externos de forma padronizada. "USB-C para IA".

stdio
SSE/HTTP
Resources
Prompts
Tools
TOOL USE LOOP 👤 User Query 🤖 LLM analisa Decide: precisa de tool? Gera tool_call JSON ⚙️ Tool Execution buscar_produto({query}) → [{id, nome, preco}] 🤖 LLM processa resultado da ferramenta loop ✦ Resposta Final Com dados reais integrados
13 — Sub-agents

Sub-agents & Roteamento

Orchestrator Router + Planner 🔍 Research web, RAG, APIs Agent 💻 Code exec, test, debug Agent ⚡ Action email, DB, CRM Agent Aggregator Combina resultados ✦ Resposta Composta

Sistemas multi-agente dividem tarefas complexas entre agentes especializados. O roteador decide qual agente (ou combinação) é mais adequado.

Padrões de Roteamento
Intent Classification
LLM classifica intenção → rota para agente correto
Semantic Router
Embeddings comparam query com exemplos por agente
Rule-based Fallback
Regex/regras simples como primeira camada rápida
const route = await router.classify(input);
const agent = agents[route.intent];
return agent.run(input, context);
14 — Loop Control

Loop Control & Orquestração

Task Input Plan / Decompose Gerar subtarefas Execute Step Tool calls, LLM, Code Evaluate Result Correto? Completo? Done? ✓ retry ⚠️ Max iter · Timeout · Budget guard

Loops de agente precisam de mecanismos de controle para evitar loops infinitos, divergência e gastos descontrolados.

loop-control.ts
class AgentLoop {
  private MAX_ITER = 20;
  private BUDGET_USD = 1.0;

  async run(task: string) {
    let iter = 0, cost = 0;
    while (iter++ < this.MAX_ITER) {
      if (cost > this.BUDGET_USD)
        throw new BudgetError();
      const step = await this.executeStep();
      cost += step.cost;
      if (step.done) return step.result;
    }
    throw new MaxIterError();
  }
}
Estratégias de Controle
🔢 Max iterations — limite absoluto
💰 Token/cost budget — controle financeiro
⏱️ Timeout — wall-clock limit
🔄 Divergence detection — loop circular
15 — Guardrails

Guardrails & Segurança

Guardrails são camadas de validação e controle que envolvem o LLM para garantir outputs seguros, on-topic e alinhados com políticas do produto.

CONTENT POLICY FILTER TOPIC & SCOPE GUARD OUTPUT VALIDATION LLM Core temp · tools · context Input → guardrails → LLM → guardrails → Output
guardrails.ts
class Guardrails {
  async validateInput(input) {
    // Prompt injection
    if (detectInjection(input))
      throw new InjectionError();
    // PII detection
    const pii = await detectPII(input);
    if (pii.found) return redact(input);
  }
  async validateOutput(output) {
    // Hallucination check
    const grounded = await
      checkGrounding(output, this.docs);
    // Schema validation
    if (this.schema)
      zod.parse(this.schema, output);
    return { output, grounded };
  }
}
Checklist de Guardrails
✅ Prompt injection detection
✅ PII redaction (CPF, emails)
✅ Content policy (toxic, NSFW)
✅ Hallucination / grounding check
✅ Output schema validation (Zod)
✅ Rate limit per user
16 — Grounding

Grounding & Interpretabilidade

Grounding ancora respostas em fontes verificáveis. Interpretabilidade nos permite entender por que o modelo gerou determinada saída.

Técnicas de Grounding
Citation Attribution
Modelo cita a fonte exata para cada afirmação [Doc N]
Faithfulness (NLI)
Classifier verifica se output é suportado pelos docs
Self-consistency
Gerar N respostas independentes e verificar concordância
Interpretabilidade
🔍 Attention visualization — tokens influentes
📊 Logit lens — predições por camada
🧩 SAE — features monosemânticas
📝 Chain-of-thought — raciocínio externalizado
grounding.ts
// Grounded response with citations
const prompt = `
Responda APENAS com informações dos
documentos abaixo. Para cada afirmação,
cite o documento com [Doc N].

DOCUMENTOS:
[Doc 1]: {{doc1}}
[Doc 2]: {{doc2}}

PERGUNTA: {{question}}

FORMATO JSON:
{
 "resposta": "...[Doc 1]...[Doc 2]",
 "fontes": ["Doc 1", "Doc 2"],
 "confianca": 0.95
}
`;

// Faithfulness evaluation
async function checkFaithfulness(claim, docs) {
  return llm.classify(`
    A afirmação: "${claim}"
    É suportada pelos documentos?
    SUPPORTED | UNSUPPORTED | N/A
  `);
}
17 — Streaming

Streaming & Event Callbacks

Streaming entrega tokens à medida que são gerados, reduzindo latência percebida de segundos para milissegundos.

Token Stream
O streaming permite que o usuário veja tokens...|
42ms
First token
68
Tokens/seg
3.2s
Latência total
Event Types
message_start → metadata, usage
content_block_delta → token chunk
tool_use → tool call detected
message_delta → stop reason
message_stop → finalização
streaming.ts
// Anthropic streaming SDK
const stream = await anthropic.messages
  .stream({
    model: 'claude-sonnet-4-5',
    max_tokens: 1024,
    messages: messages,
  });

stream
  .on('text', text => {
    appendToUI(text); // immediate!
  })
  .on('tool_use', tool => {
    showToolIndicator(tool.name);
  });

const final = await stream.finalMessage();

// Next.js SSE route
export async function POST(req) {
  const encoder = new TextEncoder();
  return new Response(
    new ReadableStream({
      async start(ctrl) {
        for await (const chunk of stream) {
          ctrl.enqueue(
            encoder.encode(toSSE(chunk))
          );
        }
      }
    }),
    { headers: {
      'Content-Type': 'text/event-stream'
    }}
  );
}
18 — Performance

Cache & Rate Limiting

Prompt caching reduz custos em até 90% para contextos repetitivos. Rate limiting protege a infra e garante fair-use.

Prompt Caching
1ª Requisição (sem cache) System prompt (50K tokens) — FULL COST User msg $0.75 2ª+ Requisição (cache hit) System prompt — CACHED ✓ (10% custo) User msg $0.08 ↓90%
// Enable prompt caching
system: [{
  type: 'text',
  text: largeSystemPrompt,
  cache_control: { type: 'ephemeral' }
}]
Camadas de Cache
⚡ KV Cache — interno ao modelo
🔄 Prompt Cache — prefixos estáticos
💾 Semantic Cache — queries similares
rate-limiter.ts
import { Ratelimit } from '@upstash/ratelimit';
import { Redis } from '@upstash/redis';

const ratelimit = new Ratelimit({
  redis: Redis.fromEnv(),
  limiter: Ratelimit.slidingWindow(
    20, '1m'
  ),
});

// In API handler
const { success, remaining, reset } =
  await ratelimit.limit(userId);

if (!success) {
  return Response.json(
    { error: 'Rate limit exceeded',
      retryAfter: reset },
    { status: 429 }
  );
}
19 — Resiliência

Error Handling & Fallback

Sistemas LLM em produção precisam de tratamento robusto de erros, retry com backoff exponencial e fallbacks para garantir disponibilidade.

Tipos de Erro LLM
429Rate limit → exponential backoff
503Overloaded → retry + fallback
400Context too long → truncate
TimeoutCancel + show partial
Fallback Chain
claude-opus
Primary
→
claude-sonnet
Fallback 1
→
gpt-4o
Fallback 2
resilient-client.ts
async function llmWithFallback(params) {
  const models = [
    'claude-opus-4-5',
    'claude-sonnet-4-5',
    'gpt-4o',
  ];
  for (const model of models) {
    try {
      return await withRetry(
        () => callLLM({ ...params, model }),
        { maxRetries: 3,
          backoff: 'exponential' }
      );
    } catch (err) {
      if (err.status === 429) {
        await sleep(getBackoff(err));
        continue;
      }
      if (isRetryable(err)) continue;
      throw err;
    }
  }
  throw new Error('All models failed');
}

function getBackoff(err) {
  return err.headers['retry-after-ms']
    ?? 2 ** attempt * 1000;
}
20 — Multimodal

Image, Speech, Video & Audio

🖼️
Image Generation

Modelos de difusão geram imagens a partir de texto.

DALL-E 3
Flux
Ideogram
await openai.images.generate({
  model: 'dall-e-3',
  prompt: description,
  size: '1024x1024',
});
🎙️
Speech & Transcription

ASR converte áudio em texto. TTS sintetiza voz natural.

Whisper
ElevenLabs
Deepgram
const text = await openai.audio
  .transcriptions.create({
    file: audioFile,
    model: 'whisper-1',
  });
🎬
Video Generation

Modelos de vídeo geram clips a partir de prompts.

Sora
Runway
Kling
const video = await replicate.run(
  'minimax/video-01',
  { input: { prompt: desc }}
);
vision.ts — Claude Vision
const analysis = await anthropic.messages.create({   messages: [{ role: 'user', content: [     { type: 'image', source: { type: 'url', url: imageUrl }},     { type: 'text', text: 'Gere uma descrição para e-commerce deste produto' },   ]}] });
21 — Arquitetura

Arquitetura Completa de Produto

CLIENT Web App Mobile App Streaming SSE API GATEWAY Auth (JWT) Rate Limiter Guardrails Router ORCHESTRATION Orchestrator LLM Context Manager Memory Store Tool Engine Loop Control Streaming Output LLM PROVIDERS Claude (Anthropic) OpenAI GPT-4o Gemini (Google) Local (Ollama) DATA LAYER Vector DB (pgvector) Redis Cache TOOLS / MCP 🌐 Web Search 💻 Code Executor 📊 Database Query 📧 Email / Slack 🖼️ Image Gen OBSERVABILITY 📈 LangFuse / Langsmith 🔍 Traces + Evals 💰 Cost tracking ⚡ Latency alerts
22 — Produto Real

Código Completo

llm-product.ts
export class LLMProduct {
  private llm: Anthropic;
  private memory: MemoryManager;
  private guardrails: Guardrails;
  private rag: RAGPipeline;

  async chat(input: ChatInput) {
    // 1. Guardrails
    const safe = await this.guardrails
      .validateInput(input.message);
    // 2. Recall memory
    const { episodes, profile } =
      await this.memory.recall(safe);
    // 3. RAG retrieval
    const context = await this.rag
      .retrieve(safe, { topK: 5 });
    // 4. Build messages
    const messages = buildMessages({
      history: episodes,
      context, profile, input: safe,
    });
    // 5. Stream with cache
    const stream = await this.llm
      .messages.stream({
        model: 'claude-sonnet-4-5',
        system: [{ type: 'text',
          text: SYSTEM_PROMPT,
          cache_control: { type: 'ephemeral' }
        }],
        tools: TOOLS,
        messages: messages,
        temperature: 0.7,
      });
    // 6. Save memory async
    const final = await stream.finalMessage();
    void this.memory.save({ input, final });
    return stream;
  }
}
api/chat/route.ts — Next.js
import { LLMProduct } from '@/lib/llm';

const product = new LLMProduct();

export async function POST(req: Request) {
  const { message, threadId } =
    await req.json();
  try {
    const userId = await getUser(req);
    await checkRateLimit(userId);
    const stream = await product.chat({
      message, userId, threadId
    });
    return new Response(
      toReadableStream(stream),
      { headers: {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        'X-Thread-Id': threadId,
      }}
    );
  } catch (err) {
    return handleError(err);
  }
}
23 — Observabilidade

Observabilidade & Evals

Em produção, você precisa ver, medir e melhorar continuamente o comportamento do LLM. Evals são os testes unitários do produto de IA.

Métricas Essenciais
⏱️ Time to First Token<200ms
🎯 Faithfulness Score>0.90
💬 Answer Relevance>0.85
💰 Cost per conversation<$0.02
🛡️ Guardrail trigger rate<2%
Stack de Observabilidade
LangFuse
LangSmith
Helicone
Braintrust
W&B
evals.ts — LLM-as-Judge
async function evalAnswer(q, answer, docs) {
  const verdict = await llm(`
    Avalie a resposta do assistente:
    
    Pergunta: ${q}
    Resposta: ${answer}
    Fontes: ${docs}
    
    Retorne JSON:
    {
     "faithfulness": 0-1,
     "relevance": 0-1,
     "completeness": 0-1,
     "reasoning": "..."
    }
  `);
  return JSON.parse(verdict);
}

// Track in LangFuse
await langfuse.score({
  traceId: trace.id,
  name: 'faithfulness',
  value: verdict.faithfulness,
});
24 — Playground

Playground & Iteração

O playground é o ambiente de experimentação rápida antes de produção. Iterar sobre prompts, modelos e parâmetros com feedback imediato.

Ciclo de Iteração
1. Hipótese 2. Testar 3. Avaliar 4. Refinar SHIP
Ferramentas
Anthropic Console
OpenAI Playground
LangFuse Prompt
Braintrust
Checklist de Produção
✅ System prompt versionado (git)
✅ Eval suite com >50 casos de teste
✅ Guardrails testados com red-teaming
✅ Rate limiting por usuário configurado
✅ Fallback model configurado
✅ Prompt caching ativado
✅ Tracing e alertas configurados
✅ Cost budget com alertas
✅ A/B test framework pronto
// A/B test prompts em produção
const variant = getVariant(userId);
const prompt = variant === 'A'
  ? PROMPT_V1 : PROMPT_V2;
await track({ variant, outcome });
✦ Mapa Completo

O Universo do Produto LLM

Produto LLM Da arquitetura ao usuário Fundamentos Transformer · Atenção Tokens · Embeddings Prompt Engineering System · CoT · Few-shot RAG & Retrieval Embed · Search · Rerank Raciocínio CoT · Reflexão · Thinking Contexto & Memória Threads · Window · Episodic Tools & Agents MCP · Sub-agents · Loop Guardrails Safety · Grounding · PII Performance Cache · Stream · Rate limit Produto Evals · Observ. · Playground Multimodal Image · Speech · Video 26 SLIDES · FUNDAMENTOS A PRODUTO · LLM.GUIDE © 2025
Transformer
RAG
Agents
Tools & MCP
Prompts
Guardrails