Bloque I — Fundamentos Block I — Foundations

Un transformer decoder (la arquitectura de TODOS los LLMs modernos, 2017-2026) repite el mismo bloque N veces (32 capas en un 7B, 80+ en un 70B). Cada bloque hace dos cosas:

1. Self-attention

Para cada token, calcula a qué OTROS tokens del contexto debería "atender" para producir su siguiente representación. Es esencialmente una suma ponderada: "este token toma el 30% de contexto del token 5, 25% del token 12, 10% del 47...". Los pesos se calculan con tres matrices aprendidas (Q, K, V).

Por qué importa: es lo que permite que un modelo "razone" sobre relaciones entre conceptos lejanos en el texto. Es también lo que cuesta caro: el coste computacional crece O(n²) con la longitud de contexto. Un prompt de 2× tokens cuesta 4× compute en attention. Por eso los modelos con 1M+ contexto (Gemini, Kimi) usan tricks como sliding window attention o sparse attention.

2. Feed-forward network (FFN / MLP)

Una red neuronal pequeña (típicamente 4× más ancha que el embedding) que se aplica a cada token independientemente. Aquí es donde se almacena la mayoría del "conocimiento" del modelo — los hechos, las asociaciones, los patrones aprendidos de internet.

Por qué importa: es por qué los modelos pueden completar "La capital de Francia es ___" sin haber visto exactamente esa frase: el FFN tiene aprendido que "Francia" + "capital" → distribución que pone "París" en top-1.

Repite ambas operaciones N veces. Tras la última capa, una proyección final convierte el vector del último token en una distribución de probabilidad sobre el vocabulario entero (típicamente 32K-256K tokens). El sampler elige el siguiente token según esa distribución.

Los modelos modernos (Claude Opus, GPT-5, Gemini 2.5, DeepSeek R2) tienen una fase EXTRA antes de la respuesta visible: generan tokens de "razonamiento interno" que el usuario no ve. Esos tokens son texto normal generado autoregresivamente — el modelo se está hablando a sí mismo, planificando, verificando.

Mecánicamente no es magia: es el mismo transformer generando tokens, solo que están envueltos en tags especiales (<thinking>…</thinking> en Claude) que el SDK filtra antes de devolver al cliente.

Por qué funciona: el modelo escribe su razonamiento intermedio, lo "lee" en attention en pasos siguientes, y eso le permite razonar multi-step de forma robusta. Es Chain-of-Thought hecho explícito y entrenado.

Coste: esos tokens internos se facturan. Con effort=high un Claude Opus puede consumir 10-30K tokens de thinking por respuesta. Activar reasoning sube calidad 5-30% en problemas complejos a cambio de 5-50× latencia y coste.

A decoder transformer (the architecture behind EVERY modern LLM, 2017-2026) repeats the same block N times (32 layers in a 7B, 80+ in a 70B). Each block does two things:

1. Self-attention

For each token, it computes which OTHER tokens in the context it should "attend" to in producing its next representation. It's essentially a weighted sum: "this token takes 30% context from token 5, 25% from token 12, 10% from token 47...". The weights are computed with three learned matrices (Q, K, V).

Why it matters: this is what lets a model "reason" about relationships between distant concepts in the text. It's also what costs a lot: compute scales O(n²) with context length. A 2× longer prompt costs 4× attention compute. That's why 1M+ context models (Gemini, Kimi) use tricks like sliding window or sparse attention.

2. Feed-forward network (FFN / MLP)

A small neural network (typically 4× wider than the embedding) applied to each token independently. This is where most of the model's "knowledge" is stored — facts, associations, patterns learned from the internet.

Why it matters: it's why models can complete "The capital of France is ___" without having seen exactly that sentence: the FFN learned that "France" + "capital" → distribution that puts "Paris" at top-1.

Repeat both operations N times. After the last layer, a final projection turns the last token's vector into a probability distribution over the entire vocabulary (typically 32K-256K tokens). The sampler picks the next token according to that distribution.

Modern models (Claude Opus, GPT-5, Gemini 2.5, DeepSeek R2) have an EXTRA phase before the visible answer: they generate "internal reasoning" tokens the user doesn't see. Those tokens are normal text generated autoregressively — the model is talking to itself, planning, verifying.

Mechanically it's not magic: same transformer generating tokens, just wrapped in special tags (<thinking>…</thinking> in Claude) that the SDK strips before returning to the client.

Why it works: the model writes its intermediate reasoning, "reads" it via attention in subsequent steps, and that lets it reason multi-step robustly. It's explicit, trained Chain-of-Thought.

Cost: those internal tokens are billed. With effort=high a Claude Opus can burn 10-30K thinking tokens per answer. Enabling reasoning lifts quality 5-30% on hard problems in exchange for 5-50× latency and cost.

Un LLM recibe una secuencia de tokens (sub-palabras) y predice el siguiente token más probable. Genera texto de forma autoregresiva, token por token. No "piensa" como un humano — es un simulador estadístico entrenado con cantidades masivas de texto.

En 2026, los modelos han evolucionado para incorporar razonamiento interno (thinking tokens), uso de herramientas, y visión.

Controla cuánta aleatoriedad introduce el sampler al elegir el siguiente token. Internamente divide los logits por T antes del softmax: T baja agudiza la distribución (el token top siempre gana), T alta la aplana (todos los tokens viables tienen oportunidad).

Rango típico: 0.0 – 2.0 (la mayoría de APIs limitan a 2.0; valores >1.5 producen alucinación e incoherencia).

Cuándo usar qué:

• 0.0 — Determinista. Mismo input → mismo output. Code generation, extracción de datos, clasificación, evals reproducibles.
• 0.2 – 0.4 — Casi determinista con un poco de variedad. Refactoring, traducción, summarization fiel.
• 0.5 – 0.7 — Equilibrio. Conversación general, asistente, tutorial. Es el default sensato.
• 0.8 – 1.0 — Creativo. Brainstorming, copywriting, ficción, generación de variantes.
• 1.0 – 1.5 — Muy aleatorio. Solo casos donde quieres explorar el espacio de salida (p.ej. self-consistency CoT).

Recorta la cola de la distribución: en cada paso solo se consideran los tokens cuyas probabilidades acumuladas suman p. Si top_p=0.9, descartamos el 10% menos probable de cada decisión. Es complementario a temperature — Anthropic recomienda tocar uno u otro, no ambos a la vez.

Rango típico: 0.7 – 1.0. Por debajo de 0.5 el modelo se vuelve repetitivo.

Defaults sensatos: top_p=1.0 y subir temperature, o temperature=1.0 y bajar top_p.

Solo considera los k tokens más probables en cada paso. Más burdo que top_p (no se adapta a la forma de la distribución). Útil cuando quieres garantizar diversidad acotada. Algunos APIs (Google, DeepSeek) lo exponen; Anthropic no.

Rango: 1 – 50. k=1 es greedy (equivalente a temperature=0).

Número máximo de tokens que el modelo puede generar antes de detenerse forzosamente. Es un cap duro, no una sugerencia. Si el modelo iba a producir más, su respuesta se trunca abruptamente (a menudo dejando JSON malformado).

Reglas prácticas:

• Respuesta corta esperada: 256 – 1024.
• Respuesta media (artículo, función completa): 2048 – 4096.
• Respuesta larga (código grande, ensayo): 8192 – 16384.
• Tareas con thinking activo: subir a 32k – 64k (los thinking tokens cuentan).

Cap por modelo: Claude 4.x 64k, GPT-5 16k, Gemini 2.5 Pro 64k, DeepSeek 8k.

Lista de strings que, si aparecen en la salida, hacen que el modelo se detenga inmediatamente. Útil cuando estás haciendo few-shot con un delimitador propio (###, END, </answer>) y no quieres que el modelo continúe alucinando un siguiente ejemplo.

Hasta 4 secuencias en la mayoría de APIs. La secuencia consumida NO aparece en la respuesta final.

Reducen la probabilidad de que el modelo repita tokens.

• frequency_penalty — penaliza tokens proporcionalmente a cuántas veces ya han aparecido (más apariciones, más penalty). Combate bucles literales.
• presence_penalty — penaliza cualquier token que ya haya aparecido al menos una vez (penalty plana). Empuja a explorar vocabulario nuevo.

Rango: -2.0 – 2.0. Default 0.0. Subir a 0.3 – 0.7 si ves repeticiones; pasar de 1.0 introduce ruido. Anthropic no los expone (Claude tiene anti-repetición interna).

Fija el RNG del sampler. Mismo seed + mismos parámetros + misma versión del modelo → misma salida (con asterisco: la mayoría de proveedores no garantizan determinismo bit-exact entre versiones de infraestructura).

Crítico para evals automatizados, debugging de prompts y reproducibilidad de papers. OpenAI y DeepSeek lo exponen; Anthropic no.

Activa los tokens de razonamiento internos antes de la respuesta visible. El modelo razona "para sí mismo" durante segundos o minutos, y luego entrega la respuesta final más sólida. Estos tokens se facturan.

Activar thinking sube calidad 5-30% en tareas multi-step (matemáticas, debugging, planificación) pero multiplica latencia 5-50× y coste por la misma proporción.

Fuerza al modelo a emitir output que cumpla un esquema determinado.

• {"type": "text"} — Default. Texto libre.
• {"type": "json_object"} — Garantiza JSON válido en la salida (OpenAI, DeepSeek, Mistral, GLM). Formato libre.
• {"type": "json_schema", "schema": {...}} — JSON estricto que cumple el schema (OpenAI, Gemini "controlled generation"). El modelo NO puede desviarse.
• Anthropic no expone response_format directamente; usa tool_use con input_schema para el mismo efecto.

Lista de herramientas que el modelo puede invocar (definidas con nombre, descripción y schema de parámetros).

• tool_choice="auto" — El modelo decide si llama a alguna o responde directamente (default).
• tool_choice="required" / "any" — Forzar llamada a alguna tool.
• tool_choice={"type":"tool","name":"X"} — Forzar tool específica.
• tool_choice="none" — Prohibir tools, responder con texto solo.

Marca bloques del prompt como cacheables. La primera llamada paga 1.25× el precio normal de input para escribirlos en caché; las siguientes pagan 0.10× para leerlos. TTL típico 5 min (extensible a 1 h con "ttl": "1h"). Critical para system prompts largos y RAG con docs repetidos.

El system prompt tiene prioridad máxima sobre los mensajes del usuario. Es donde defines rol, reglas, formato esperado, restricciones de seguridad. NO va dentro de messages[] en Anthropic (es un parámetro top-level system); en OpenAI/DeepSeek va como primer mensaje con role: "system".

An LLM receives a sequence of tokens (sub-words) and predicts the next most likely token. It generates text autoregressively, token by token. It does not "think" like a human — it's a statistical simulator trained on massive amounts of text.

By 2026, models have evolved to incorporate internal reasoning (thinking tokens), tool use, and vision.

Controls how much randomness the sampler injects when picking the next token. Internally it divides the logits by T before softmax: low T sharpens the distribution (top token always wins), high T flattens it (every viable token gets a chance).

Typical range: 0.0 – 2.0 (most APIs cap at 2.0; values >1.5 produce hallucination and incoherence).

When to use what:

• 0.0 — Deterministic. Same input → same output. Code generation, data extraction, classification, reproducible evals.
• 0.2 – 0.4 — Almost deterministic with a touch of variety. Refactoring, faithful translation, summarization.
• 0.5 – 0.7 — Balanced. General conversation, assistant, tutorial. The sensible default.
• 0.8 – 1.0 — Creative. Brainstorming, copywriting, fiction, generating variants.
• 1.0 – 1.5 — Very random. Only when you want to explore the output space (e.g. self-consistency CoT).

Trims the tail of the distribution: at each step only tokens whose cumulative probabilities sum to p are considered. With top_p=0.9, you discard the 10% least likely tokens at every decision. It's complementary to temperature — Anthropic recommends tuning one or the other, not both at once.

Typical range: 0.7 – 1.0. Below 0.5 the model becomes repetitive.

Sensible defaults: top_p=1.0 and raise temperature, or temperature=1.0 and lower top_p.

Only considers the k most likely tokens at each step. Cruder than top_p (it doesn't adapt to the shape of the distribution). Useful when you want bounded diversity guaranteed. Some APIs (Google, DeepSeek) expose it; Anthropic doesn't.

Range: 1 – 50. k=1 is greedy (equivalent to temperature=0).

Maximum number of tokens the model can generate before being forcibly stopped. It's a hard cap, not a hint. If the model intended to produce more, the response truncates abruptly (often leaving malformed JSON).

Practical rules:

• Short response expected: 256 – 1024.
• Medium response (article, full function): 2048 – 4096.
• Long response (large code, essay): 8192 – 16384.
• Tasks with thinking enabled: raise to 32k – 64k (thinking tokens count).

Per-model caps: Claude 4.x 64k, GPT-5 16k, Gemini 2.5 Pro 64k, DeepSeek 8k.

List of strings that, if they appear in the output, make the model stop immediately. Useful when you're doing few-shot with your own delimiter (###, END, </answer>) and don't want the model to keep hallucinating a next example.

Up to 4 sequences in most APIs. The consumed sequence is NOT included in the final response.

Reduce the probability of the model repeating tokens.

• frequency_penalty — penalizes tokens proportionally to how many times they've appeared (more occurrences, more penalty). Fights literal loops.
• presence_penalty — penalizes any token that appeared at least once (flat penalty). Pushes the model to explore new vocabulary.

Range: -2.0 – 2.0. Default 0.0. Raise to 0.3 – 0.7 if you see repetitions; above 1.0 introduces noise. Anthropic doesn't expose them (Claude has internal anti-repetition).

Fixes the sampler RNG. Same seed + same parameters + same model version → same output (asterisk: most providers don't guarantee bit-exact determinism across infra versions).

Critical for automated evals, prompt debugging, and paper reproducibility. OpenAI and DeepSeek expose it; Anthropic doesn't.

Enables internal reasoning tokens before the visible answer. The model thinks "to itself" for seconds or minutes, then delivers a stronger final answer. These tokens are billed.

Enabling thinking lifts quality 5-30% on multi-step tasks (math, debugging, planning) but multiplies latency 5-50× and cost proportionally.

Forces the model to emit output that conforms to a given schema.

• {"type": "text"} — Default. Free text.
• {"type": "json_object"} — Guarantees valid JSON in the output (OpenAI, DeepSeek, Mistral, GLM). Free form.
• {"type": "json_schema", "schema": {...}} — Strict JSON conforming to the schema (OpenAI, Gemini "controlled generation"). The model CANNOT deviate.
• Anthropic doesn't expose response_format directly; use tool_use with input_schema for the same effect.

List of tools the model can invoke (defined with name, description, and parameter schema).

• tool_choice="auto" — The model decides whether to call any tool or answer directly (default).
• tool_choice="required" / "any" — Force a tool call.
• tool_choice={"type":"tool","name":"X"} — Force a specific tool.
• tool_choice="none" — Forbid tools, text-only response.

Marks blocks of the prompt as cacheable. The first call pays 1.25× the normal input price to write to cache; subsequent calls pay 0.10× to read it. Typical TTL 5 min (extensible to 1 h with "ttl": "1h"). Critical for long system prompts and RAG with repeated docs.

The system prompt has top priority over user messages. It's where you define role, rules, expected format, safety constraints. It does NOT go inside messages[] in Anthropic (it's a top-level system parameter); in OpenAI/DeepSeek it goes as the first message with role: "system".