santismm-knowledge-mcp 0.2.1

package/content/patterns/parallelization.json

@@ -0,0 +1,180 @@
+{
+  "slug": "parallelization",
+  "category": "orchestration",
+  "updated": "2026-06-21",
+  "version": "1.0",
+  "technologies": ["LangGraph", "Async runtimes", "OpenAI Agents SDK", "Map-reduce frameworks"],
+  "related": ["prompt-chaining", "orchestrator-workers", "evaluator-optimizer"],
+  "references": [
+    { "title": "Anthropic — Building Effective Agents (2024)", "url": "https://www.anthropic.com/research/building-effective-agents" }
+  ],
+  "evidence": {
+    "evidenceLevel": "industry_observation",
+    "confidenceLevel": "high",
+    "sourceType": ["industry_observation"]
+  },
+  "locales": {
+    "en": {
+      "name": "Parallelization",
+      "summary": "Parallelization runs multiple LLM calls at the same time and aggregates the results. Two flavors: sectioning (split a task into independent subtasks run in parallel) and voting (run the same task several times to improve reliability or coverage). It cuts latency and can raise quality.",
+      "problem": "Running independent subtasks one after another wastes time, and a single sample of a hard task can be unreliable.",
+      "context": "Use parallelization when subtasks are independent (sectioning), or when multiple attempts at the same task improve confidence or coverage (voting).",
+      "solution": [
+        "Sectioning: split the work into independent pieces, run them concurrently, and combine the outputs. Voting: run the same prompt multiple times (or with variations) and aggregate by majority, union or a judge.",
+        "Both reduce wall-clock time versus sequential execution; voting additionally trades extra cost for higher reliability on tasks where a single sample is risky."
+      ],
+      "components": ["Task splitter", "Concurrent workers", "Aggregator (merge / vote / judge)"],
+      "benefits": [
+        "Lower latency by running calls concurrently.",
+        "Voting improves reliability and coverage.",
+        "Each parallel call stays simple and focused."
+      ],
+      "risks": [
+        "Voting multiplies token cost.",
+        "Aggregation logic can be tricky to get right.",
+        "Subtasks assumed independent may actually interact."
+      ],
+      "whenNot": [
+        "When subtasks depend on each other's output — chain them.",
+        "When cost is tight and a single call suffices.",
+        "When results cannot be aggregated meaningfully."
+      ],
+      "examples": [
+        "Summarizing many documents at once, then merging the summaries.",
+        "Running a safety check in parallel with the main response.",
+        "Sampling an answer several times and taking the majority."
+      ],
+      "kpis": [
+        { "metric": "Latency reduction vs. sequential", "note": "Wall-clock saved by running calls concurrently; the whole point of the pattern." },
+        { "metric": "Aggregation quality", "note": "Whether merging the parallel outputs preserves correctness — the hard part is the join, not the fan-out." },
+        { "metric": "Concurrency cost", "note": "Total tokens across all parallel branches; you trade money for speed, so watch the multiplier." },
+        { "metric": "Rate-limit / throttle rate", "note": "How often parallel calls hit provider rate limits, which silently serializes or fails them." }
+      ],
+      "failureModes": [
+        "Aggregation errors: parallel results are correct individually but combined wrongly (double-counting, contradictions).",
+        "Rate limiting turns intended parallelism back into slow, serialized calls.",
+        "Cost surprise: N parallel branches cost N× even when only one result is used.",
+        "Partial failure handling: one branch fails and the aggregator either blocks or silently drops it."
+      ],
+      "lessons": [
+        "Design the aggregation step first — combining results well is harder than splitting the work.",
+        "Respect provider rate limits with batching or backoff, or parallelism evaporates.",
+        "Only parallelize independent sub-tasks; dependencies force a sequence anyway.",
+        "Decide explicitly how partial failures are handled before they happen in production."
+      ],
+      "faqs": [
+        { "q": "What is the difference between sectioning and voting?", "a": "Sectioning splits one task into different independent subtasks; voting runs the same task multiple times to aggregate for reliability." },
+        { "q": "Does voting always improve quality?", "a": "Often, on tasks where samples vary, but it multiplies cost. Reserve it for high-stakes steps where a single sample is risky." },
+        { "q": "How do I combine parallel results?", "a": "Depending on the case: concatenate sections, take a majority vote, union the findings, or use a judge model to synthesize." }
+      ]
+    },
+    "es": {
+      "name": "Paralelización (Parallelization)",
+      "summary": "La paralelización ejecuta varias llamadas al LLM a la vez y agrega los resultados. Dos variantes: seccionado (dividir una tarea en subtareas independientes en paralelo) y votación (ejecutar la misma tarea varias veces para mejorar fiabilidad o cobertura). Reduce la latencia y puede subir la calidad.",
+      "problem": "Ejecutar subtareas independientes una tras otra desperdicia tiempo, y una sola muestra de una tarea difícil puede ser poco fiable.",
+      "context": "Usa la paralelización cuando las subtareas son independientes (seccionado), o cuando varios intentos de la misma tarea mejoran la confianza o cobertura (votación).",
+      "solution": [
+        "Seccionado: divide el trabajo en piezas independientes, ejecútalas en paralelo y combina las salidas. Votación: ejecuta el mismo prompt varias veces (o con variaciones) y agrega por mayoría, unión o un juez.",
+        "Ambas reducen el tiempo real frente a la ejecución secuencial; la votación además cambia coste extra por mayor fiabilidad en tareas donde una sola muestra es arriesgada."
+      ],
+      "components": ["Divisor de tareas", "Trabajadores concurrentes", "Agregador (fusión / voto / juez)"],
+      "benefits": [
+        "Menor latencia al ejecutar llamadas en concurrencia.",
+        "La votación mejora la fiabilidad y la cobertura.",
+        "Cada llamada paralela se mantiene simple y enfocada."
+      ],
+      "risks": [
+        "La votación multiplica el coste de tokens.",
+        "La lógica de agregación puede ser difícil de acertar.",
+        "Subtareas asumidas independientes pueden interactuar en realidad."
+      ],
+      "whenNot": [
+        "Cuando las subtareas dependen de la salida de otra: encadénalas.",
+        "Cuando el coste es ajustado y basta una sola llamada.",
+        "Cuando los resultados no se pueden agregar de forma significativa."
+      ],
+      "examples": [
+        "Resumir muchos documentos a la vez y luego fusionar los resúmenes.",
+        "Ejecutar una comprobación de seguridad en paralelo con la respuesta principal.",
+        "Muestrear una respuesta varias veces y tomar la mayoría."
+      ],
+      "kpis": [
+        { "metric": "Reducción de latencia vs. secuencial", "note": "Tiempo ahorrado al ejecutar llamadas en paralelo; la razón de ser del patrón." },
+        { "metric": "Calidad de la agregación", "note": "Si combinar las salidas paralelas preserva la corrección; lo difícil es la unión, no el fan-out." },
+        { "metric": "Coste de concurrencia", "note": "Tokens totales de todas las ramas paralelas; cambias dinero por velocidad, vigila el multiplicador." },
+        { "metric": "Tasa de límite de tasa / throttle", "note": "Con qué frecuencia las llamadas paralelas chocan con los límites del proveedor, que las serializa o falla en silencio." }
+      ],
+      "failureModes": [
+        "Errores de agregación: resultados paralelos correctos por separado pero mal combinados (doble conteo, contradicciones).",
+        "El límite de tasa convierte el paralelismo previsto en llamadas lentas y serializadas.",
+        "Sorpresa de coste: N ramas paralelas cuestan N× aunque solo se use un resultado.",
+        "Manejo de fallo parcial: una rama falla y el agregador o se bloquea o la descarta en silencio."
+      ],
+      "lessons": [
+        "Diseña primero el paso de agregación: combinar bien los resultados es más difícil que dividir el trabajo.",
+        "Respeta los límites de tasa del proveedor con batching o backoff, o el paralelismo se evapora.",
+        "Paraleliza solo subtareas independientes; las dependencias fuerzan una secuencia de todos modos.",
+        "Decide explícitamente cómo se manejan los fallos parciales antes de que ocurran en producción."
+      ],
+      "faqs": [
+        { "q": "¿Diferencia entre seccionado y votación?", "a": "El seccionado divide una tarea en subtareas independientes distintas; la votación ejecuta la misma tarea varias veces para agregar por fiabilidad." },
+        { "q": "¿La votación siempre mejora la calidad?", "a": "A menudo, en tareas donde las muestras varían, pero multiplica el coste. Resérvala para pasos críticos donde una sola muestra es arriesgada." },
+        { "q": "¿Cómo combino resultados paralelos?", "a": "Según el caso: concatenar secciones, tomar voto mayoritario, unir los hallazgos o usar un modelo juez para sintetizar." }
+      ]
+    },
+    "pt": {
+      "name": "Paralelização (Parallelization)",
+      "summary": "A paralelização executa várias chamadas ao LLM ao mesmo tempo e agrega os resultados. Duas variantes: seccionamento (dividir uma tarefa em subtarefas independentes em paralelo) e votação (executar a mesma tarefa várias vezes para melhorar confiabilidade ou cobertura). Reduz a latência e pode aumentar a qualidade.",
+      "problem": "Executar subtarefas independentes uma após a outra desperdiça tempo, e uma única amostra de uma tarefa difícil pode ser pouco confiável.",
+      "context": "Use a paralelização quando as subtarefas são independentes (seccionamento), ou quando várias tentativas da mesma tarefa melhoram a confiança ou cobertura (votação).",
+      "solution": [
+        "Seccionamento: divida o trabalho em peças independentes, execute-as em paralelo e combine as saídas. Votação: execute o mesmo prompt várias vezes (ou com variações) e agregue por maioria, união ou um juiz.",
+        "Ambas reduzem o tempo real frente à execução sequencial; a votação além disso troca custo extra por maior confiabilidade em tarefas em que uma única amostra é arriscada."
+      ],
+      "components": ["Divisor de tarefas", "Trabalhadores concorrentes", "Agregador (fusão / voto / juiz)"],
+      "benefits": [
+        "Menor latência ao executar chamadas em concorrência.",
+        "A votação melhora a confiabilidade e a cobertura.",
+        "Cada chamada paralela se mantém simples e focada."
+      ],
+      "risks": [
+        "A votação multiplica o custo de tokens.",
+        "A lógica de agregação pode ser difícil de acertar.",
+        "Subtarefas assumidas independentes podem interagir na realidade."
+      ],
+      "whenNot": [
+        "Quando as subtarefas dependem da saída de outra: encadeie-as.",
+        "Quando o custo é apertado e basta uma única chamada.",
+        "Quando os resultados não podem ser agregados de forma significativa."
+      ],
+      "examples": [
+        "Resumir muitos documentos ao mesmo tempo e depois fundir os resumos.",
+        "Executar uma verificação de segurança em paralelo com a resposta principal.",
+        "Amostrar uma resposta várias vezes e tomar a maioria."
+      ],
+      "kpis": [
+        { "metric": "Redução de latência vs. sequencial", "note": "Tempo economizado ao executar chamadas em paralelo; a razão de ser do padrão." },
+        { "metric": "Qualidade da agregação", "note": "Se combinar as saídas paralelas preserva a correção; o difícil é a junção, não o fan-out." },
+        { "metric": "Custo de concorrência", "note": "Tokens totais de todas as ramificações paralelas; você troca dinheiro por velocidade, vigie o multiplicador." },
+        { "metric": "Taxa de rate limit / throttle", "note": "Com que frequência as chamadas paralelas batem nos limites do provedor, que as serializa ou falha em silêncio." }
+      ],
+      "failureModes": [
+        "Erros de agregação: resultados paralelos corretos isoladamente mas mal combinados (dupla contagem, contradições).",
+        "O rate limit transforma o paralelismo pretendido em chamadas lentas e serializadas.",
+        "Surpresa de custo: N ramificações paralelas custam N× mesmo quando só um resultado é usado.",
+        "Tratamento de falha parcial: uma ramificação falha e o agregador ou bloqueia ou a descarta em silêncio."
+      ],
+      "lessons": [
+        "Projete primeiro o passo de agregação: combinar bem os resultados é mais difícil que dividir o trabalho.",
+        "Respeite os limites de taxa do provedor com batching ou backoff, ou o paralelismo evapora.",
+        "Paralelize só subtarefas independentes; dependências forçam uma sequência de qualquer forma.",
+        "Decida explicitamente como as falhas parciais são tratadas antes que ocorram em produção."
+      ],
+      "faqs": [
+        { "q": "Diferença entre seccionamento e votação?", "a": "O seccionamento divide uma tarefa em subtarefas independentes distintas; a votação executa a mesma tarefa várias vezes para agregar por confiabilidade." },
+        { "q": "A votação sempre melhora a qualidade?", "a": "Muitas vezes, em tarefas em que as amostras variam, mas multiplica o custo. Reserve-a para passos críticos em que uma única amostra é arriscada." },
+        { "q": "Como combino resultados paralelos?", "a": "Conforme o caso: concatenar seções, tomar voto majoritário, unir os achados ou usar um modelo juiz para sintetizar." }
+      ]
+    }
+  }
+}

package/content/patterns/prompt-chaining.json

@@ -0,0 +1,181 @@
+{
+  "slug": "prompt-chaining",
+  "category": "orchestration",
+  "updated": "2026-06-21",
+  "version": "1.0",
+  "featured": true,
+  "technologies": ["LangGraph", "OpenAI Agents SDK", "Claude Agent SDK", "Workflow engines"],
+  "related": ["routing", "orchestrator-workers", "evaluator-optimizer"],
+  "references": [
+    { "title": "Anthropic — Building Effective Agents (2024)", "url": "https://www.anthropic.com/research/building-effective-agents" }
+  ],
+  "evidence": {
+    "evidenceLevel": "industry_observation",
+    "confidenceLevel": "high",
+    "sourceType": ["industry_observation", "paper"]
+  },
+  "locales": {
+    "en": {
+      "name": "Prompt Chaining",
+      "summary": "Prompt chaining decomposes a task into a fixed sequence of LLM calls, where each step works on the output of the previous one. It trades a little latency for much higher accuracy and control, and is the simplest workflow pattern: use it whenever a task cleanly splits into ordered subtasks.",
+      "problem": "A single prompt asked to do several things at once produces lower-quality, harder-to-control output, and is difficult to debug when it goes wrong.",
+      "context": "Use prompt chaining when a task decomposes into a clear, ordered sequence of subtasks — for example outline, then draft, then edit — and each step benefits from the previous step's result.",
+      "solution": [
+        "Break the task into discrete steps and run one LLM call per step, passing each output to the next. Optionally add programmatic checks (gates) between steps to validate intermediate results before continuing.",
+        "Because each call has one focused job, prompts are simpler, outputs are more reliable, and failures are localized to a specific step that you can inspect and fix."
+      ],
+      "components": ["Ordered steps", "Per-step prompt", "Inter-step gates / validation", "State passed between steps"],
+      "benefits": [
+        "Higher accuracy by giving each call one focused job.",
+        "Easier to debug — failures localize to a step.",
+        "Validation gates can catch errors between steps."
+      ],
+      "risks": [
+        "Higher total latency from sequential calls.",
+        "Errors can compound down the chain if not checked.",
+        "Too many steps add cost and brittleness."
+      ],
+      "whenNot": [
+        "When the task is simple enough for a single call.",
+        "When subtasks are independent — parallelize instead.",
+        "When the path is unknown up front — use an agent loop."
+      ],
+      "examples": [
+        "Generate an outline, then write each section, then revise for tone.",
+        "Extract structured fields, then validate them, then summarize.",
+        "Translate a document, then check the translation against the source."
+      ],
+      "kpis": [
+        { "metric": "End-to-end success rate", "note": "Share of chains that produce a correct final result; errors compound across steps." },
+        { "metric": "Per-step error rate", "note": "Failure rate at each link — a 95%-reliable step chained five times yields ~77% end to end." },
+        { "metric": "Total latency & cost", "note": "Sum across every call in the chain; more steps mean more of both." },
+        { "metric": "Recovery rate", "note": "How often a failed intermediate step is caught and corrected rather than silently propagated." }
+      ],
+      "failureModes": [
+        "Error propagation: a mistake early in the chain corrupts every downstream step.",
+        "Latency and cost accumulation as the chain grows longer.",
+        "Brittle hand-offs when one step's output format doesn't match the next step's expected input.",
+        "Lost context across steps, so later links forget constraints set earlier."
+      ],
+      "lessons": [
+        "Validate or gate-check between steps so errors are caught before they propagate.",
+        "Keep chains as short as the task allows; every extra step multiplies failure probability.",
+        "Pin the output contract of each step so hand-offs don't break silently.",
+        "Use chaining for genuinely sequential work; parallelize independent steps instead."
+      ],
+      "faqs": [
+        { "q": "How is prompt chaining different from an agent?", "a": "Prompt chaining follows a fixed, predefined sequence. An agent decides its own steps dynamically. Prefer chaining when the path is known in advance." },
+        { "q": "When should I add gates between steps?", "a": "Whenever an intermediate result must meet a condition before proceeding — it stops errors from propagating down the chain." },
+        { "q": "Does chaining increase cost?", "a": "Yes, modestly — more calls mean more tokens and latency — but the gain in reliability usually outweighs it for multi-part tasks." }
+      ]
+    },
+    "es": {
+      "name": "Encadenamiento de Prompts (Prompt Chaining)",
+      "summary": "El encadenamiento de prompts descompone una tarea en una secuencia fija de llamadas al LLM, donde cada paso trabaja sobre la salida del anterior. Cambia algo de latencia por mucha más precisión y control, y es el patrón de flujo más simple: úsalo cuando una tarea se divide limpiamente en subtareas ordenadas.",
+      "problem": "Un solo prompt al que se le pide hacer varias cosas a la vez produce salidas de menor calidad, más difíciles de controlar y de depurar cuando fallan.",
+      "context": "Usa el encadenamiento cuando una tarea se descompone en una secuencia clara y ordenada de subtareas —por ejemplo esquema, luego borrador, luego edición— y cada paso se beneficia del resultado del anterior.",
+      "solution": [
+        "Divide la tarea en pasos discretos y ejecuta una llamada al LLM por paso, pasando cada salida a la siguiente. Opcionalmente añade comprobaciones programáticas (gates) entre pasos para validar resultados intermedios antes de continuar.",
+        "Como cada llamada tiene un único trabajo enfocado, los prompts son más simples, las salidas más fiables y los fallos quedan localizados en un paso concreto que puedes inspeccionar y corregir."
+      ],
+      "components": ["Pasos ordenados", "Prompt por paso", "Gates / validación entre pasos", "Estado pasado entre pasos"],
+      "benefits": [
+        "Mayor precisión al dar a cada llamada un único trabajo enfocado.",
+        "Más fácil de depurar: los fallos se localizan en un paso.",
+        "Los gates de validación pueden atrapar errores entre pasos."
+      ],
+      "risks": [
+        "Mayor latencia total por las llamadas secuenciales.",
+        "Los errores pueden acumularse en la cadena si no se comprueban.",
+        "Demasiados pasos añaden coste y fragilidad."
+      ],
+      "whenNot": [
+        "Cuando la tarea es lo bastante simple para una sola llamada.",
+        "Cuando las subtareas son independientes: paraleliza en su lugar.",
+        "Cuando el camino no se conoce de antemano: usa un bucle de agente."
+      ],
+      "examples": [
+        "Generar un esquema, luego escribir cada sección, luego revisar el tono.",
+        "Extraer campos estructurados, luego validarlos, luego resumir.",
+        "Traducir un documento, luego comprobar la traducción contra el original."
+      ],
+      "kpis": [
+        { "metric": "Tasa de éxito de extremo a extremo", "note": "Proporción de cadenas que producen un resultado final correcto; los errores se acumulan entre pasos." },
+        { "metric": "Tasa de error por paso", "note": "Fallo en cada eslabón: un paso fiable al 95% encadenado cinco veces da ~77% de extremo a extremo." },
+        { "metric": "Latencia y coste totales", "note": "Suma de todas las llamadas de la cadena; más pasos significan más de ambos." },
+        { "metric": "Tasa de recuperación", "note": "Con qué frecuencia un paso intermedio fallido se detecta y corrige en vez de propagarse en silencio." }
+      ],
+      "failureModes": [
+        "Propagación de errores: un fallo temprano en la cadena corrompe todos los pasos posteriores.",
+        "Acumulación de latencia y coste a medida que la cadena se alarga.",
+        "Transferencias frágiles cuando el formato de salida de un paso no coincide con la entrada esperada del siguiente.",
+        "Pérdida de contexto entre pasos, de modo que eslabones posteriores olvidan restricciones fijadas antes."
+      ],
+      "lessons": [
+        "Valida o verifica entre pasos para detectar errores antes de que se propaguen.",
+        "Mantén las cadenas tan cortas como permita la tarea; cada paso extra multiplica la probabilidad de fallo.",
+        "Fija el contrato de salida de cada paso para que las transferencias no se rompan en silencio.",
+        "Usa el encadenamiento para trabajo genuinamente secuencial; paraleliza los pasos independientes."
+      ],
+      "faqs": [
+        { "q": "¿En qué se diferencia del agente?", "a": "El encadenamiento sigue una secuencia fija predefinida. Un agente decide sus propios pasos de forma dinámica. Prefiere el encadenamiento cuando el camino se conoce de antemano." },
+        { "q": "¿Cuándo debo añadir gates entre pasos?", "a": "Siempre que un resultado intermedio deba cumplir una condición antes de seguir: evita que los errores se propaguen por la cadena." },
+        { "q": "¿El encadenamiento aumenta el coste?", "a": "Sí, moderadamente —más llamadas significan más tokens y latencia— pero la ganancia en fiabilidad suele compensarlo en tareas de varias partes." }
+      ]
+    },
+    "pt": {
+      "name": "Encadeamento de Prompts (Prompt Chaining)",
+      "summary": "O encadeamento de prompts decompõe uma tarefa numa sequência fixa de chamadas ao LLM, em que cada passo trabalha sobre a saída do anterior. Troca um pouco de latência por muito mais precisão e controle, e é o padrão de fluxo mais simples: use-o quando uma tarefa se divide limpamente em subtarefas ordenadas.",
+      "problem": "Um único prompt ao qual se pede fazer várias coisas ao mesmo tempo produz saídas de menor qualidade, mais difíceis de controlar e de depurar quando falham.",
+      "context": "Use o encadeamento quando uma tarefa se decompõe numa sequência clara e ordenada de subtarefas — por exemplo esboço, depois rascunho, depois edição — e cada passo se beneficia do resultado do anterior.",
+      "solution": [
+        "Divida a tarefa em passos discretos e execute uma chamada ao LLM por passo, passando cada saída à seguinte. Opcionalmente adicione verificações programáticas (gates) entre passos para validar resultados intermediários antes de continuar.",
+        "Como cada chamada tem um único trabalho focado, os prompts são mais simples, as saídas mais confiáveis e as falhas ficam localizadas num passo concreto que você pode inspecionar e corrigir."
+      ],
+      "components": ["Passos ordenados", "Prompt por passo", "Gates / validação entre passos", "Estado passado entre passos"],
+      "benefits": [
+        "Maior precisão ao dar a cada chamada um único trabalho focado.",
+        "Mais fácil de depurar: as falhas se localizam num passo.",
+        "Os gates de validação podem capturar erros entre passos."
+      ],
+      "risks": [
+        "Maior latência total pelas chamadas sequenciais.",
+        "Os erros podem se acumular na cadeia se não forem verificados.",
+        "Passos demais adicionam custo e fragilidade."
+      ],
+      "whenNot": [
+        "Quando a tarefa é simples o bastante para uma única chamada.",
+        "Quando as subtarefas são independentes: paralelize em vez disso.",
+        "Quando o caminho não é conhecido de antemão: use um laço de agente."
+      ],
+      "examples": [
+        "Gerar um esboço, depois escrever cada seção, depois revisar o tom.",
+        "Extrair campos estruturados, depois validá-los, depois resumir.",
+        "Traduzir um documento, depois verificar a tradução contra o original."
+      ],
+      "kpis": [
+        { "metric": "Taxa de sucesso ponta a ponta", "note": "Proporção de cadeias que produzem um resultado final correto; os erros se acumulam entre passos." },
+        { "metric": "Taxa de erro por passo", "note": "Falha em cada elo: um passo confiável a 95% encadeado cinco vezes dá ~77% ponta a ponta." },
+        { "metric": "Latência e custo totais", "note": "Soma de todas as chamadas da cadeia; mais passos significam mais de ambos." },
+        { "metric": "Taxa de recuperação", "note": "Com que frequência um passo intermediário falho é detectado e corrigido em vez de propagado em silêncio." }
+      ],
+      "failureModes": [
+        "Propagação de erros: uma falha cedo na cadeia corrompe todos os passos seguintes.",
+        "Acúmulo de latência e custo à medida que a cadeia se alonga.",
+        "Transferências frágeis quando o formato de saída de um passo não coincide com a entrada esperada do seguinte.",
+        "Perda de contexto entre passos, de modo que elos posteriores esquecem restrições fixadas antes."
+      ],
+      "lessons": [
+        "Valide ou verifique entre passos para detectar erros antes que se propaguem.",
+        "Mantenha as cadeias tão curtas quanto a tarefa permitir; cada passo extra multiplica a probabilidade de falha.",
+        "Fixe o contrato de saída de cada passo para que as transferências não quebrem em silêncio.",
+        "Use o encadeamento para trabalho genuinamente sequencial; paralelize os passos independentes."
+      ],
+      "faqs": [
+        { "q": "Como difere de um agente?", "a": "O encadeamento segue uma sequência fixa predefinida. Um agente decide seus próprios passos de forma dinâmica. Prefira o encadeamento quando o caminho é conhecido de antemão." },
+        { "q": "Quando devo adicionar gates entre passos?", "a": "Sempre que um resultado intermediário precise cumprir uma condição antes de prosseguir: evita que os erros se propaguem pela cadeia." },
+        { "q": "O encadeamento aumenta o custo?", "a": "Sim, moderadamente — mais chamadas significam mais tokens e latência — mas o ganho em confiabilidade costuma compensar em tarefas de várias partes." }
+      ]
+    }
+  }
+}