Saltar a contenido

Capítulo 2

Cómo piensa una Inteligencia Artificial

2.0 Objetivo del capítulo

Al finalizar este capítulo serás capaz de:

  • Comprender cómo funcionan los modelos de lenguaje (LLM) a nivel conceptual.
  • Entender qué son los tokens y por qué son importantes. [web:89]
  • Comprender qué significa contexto en una conversación con IA. [web:74]
  • Comprender la importancia de la ventana de contexto y sus límites. [web:74][web:80]
  • Entender cómo un modelo predice texto mediante probabilidades.
  • Comprender qué son las alucinaciones y por qué ocurren. [web:100]
  • Entender conceptos como temperatura y su relación con la creatividad de la respuesta. [web:79][web:86]
  • Diseñar mejores prompts gracias a la comprensión del funcionamiento interno de un modelo.

No vamos a entrar en detalles matemáticos ni en la arquitectura profunda de redes neuronales, ni en procesos de entrenamiento específicos. Nos centraremos en aquello que realmente te ayuda a escribir mejores prompts y a interpretar mejor las respuestas que obtienes. [web:31][web:68]

Nota
El objetivo no es que “aprendas a programar modelos”, sino que entiendas lo suficiente de su funcionamiento para comunicarte con ellos de forma más efectiva.

2.1 ¿Cómo piensa realmente una IA?

Lo primero que debemos aclarar es que un modelo de lenguaje grande (LLM) no “piensa” como una persona. No tiene conciencia, intención propia ni comprensión profunda del mundo en el sentido humano. Lo que hace es calcular, a partir de un contexto dado, cuál es la continuación de texto más probable. [web:31][web:68]

OpenAI y Google explican que los LLM funcionan como sistemas de predicción del siguiente token: dado un historial de texto, el modelo estima la probabilidad de cada posible token que podría seguir y elige uno de ellos, repitiendo ese proceso muchas veces hasta producir una respuesta completa. [web:31][web:68][web:89]

Podemos imaginarlo con una analogía sencilla. Piensa en la frase:

Hoy voy a preparar una taza de

Si completas la frase de manera intuitiva, probablemente piensas en palabras como "café" o "té". Esto significa que, en tu experiencia, "café" y "té" tienen alta probabilidad de aparecer después de “una taza de”. Otros finales como "arena" o "cemento" son posibles, pero mucho menos probables. Los modelos de lenguaje hacen algo similar: estiman probabilidades de continuación basadas en patrones aprendidos durante su entrenamiento. [web:68][web:84]

graph TD
  A[Texto de entrada] --> B[Estimación de probabilidades]
  B --> C[Selección del siguiente token]
  C --> D[Actualización del contexto]
  D --> B

En este diagrama, vemos un ciclo simplificado: el modelo recibe texto, estima probabilidades, selecciona un token, actualiza el contexto y repite. Desde fuera parece que “piensa” de manera coherente, pero internamente está realizando una secuencia de decisiones probabilísticas. [web:31][web:68]

[Ilustración: Una línea de texto con huecos marcados donde el modelo “elige” la siguiente palabra. Encima de cada hueco aparecen varias opciones con números de probabilidad (por ejemplo, 0.6 para “café”, 0.3 para “té”, 0.1 para “agua”), mostrando que el modelo selecciona entre opciones según su probabilidad.]

Curiosidad
En documentación oficial se habla de “sampling” (muestreo) para describir cómo el modelo selecciona el siguiente token a partir de una distribución de probabilidades. [web:79][web:86]

Conclusión de la sección: un LLM no razona como un humano, pero puede producir texto sorprendentemente coherente porque es muy bueno en una tarea específica: predecir qué texto tiene más probabilidades de seguir a otro, dentro de un contexto dado. Entender esto es clave para diseñar prompts que guíen correctamente esa predicción. [web:31][web:68]

2.2 ¿Qué son los tokens?

Los modelos de lenguaje no procesan directamente “palabras” tal como las escribimos, sino unidades más pequeñas llamadas tokens. OpenAI define los tokens como “bloques de construcción del texto”: pueden ser tan cortos como un carácter o tan largos como una palabra completa, dependiendo del idioma y del contexto. [web:89]

En inglés, una regla práctica es que 1 token suele corresponder a unas 4 letras o a aproximadamente tres cuartas partes de una palabra. 100 tokens equivalen a unas 75 palabras, y un párrafo típico puede rondar los 100 tokens. [web:89] Esto varía entre modelos y codificaciones, pero nos da una idea aproximada.

| Unidad      | Ejemplo                       | Comentario                                  |
|------------|-------------------------------|---------------------------------------------|
| Caracter   | "a", "b", "?"              | Puede ser parte de un token                 |
| Palabra    | "Inteligencia"               | Puede ser uno o varios tokens               |
| Token      | "Inte", "ligencia"          | Segmento interno usado por el modelo        |

En la práctica, los tokens importan por varias razones:

  1. Costos: la mayoría de proveedores de IA (OpenAI, Anthropic, Google, Microsoft) cobran por número de tokens procesados (entrada + salida). Controlar cuántos tokens envías y recibes impacta directamente en el costo de tus aplicaciones. [web:89][web:95]
  2. Límites de contexto: cada modelo tiene un máximo de tokens que puede manejar en su ventana de contexto (la suma de lo que envías y lo que genera). Superar ese límite produce errores o truncamiento de contenido. [web:89][web:91]
  3. Diseño de prompts: saber que un modelo mide “tamaño” en tokens te ayuda a ajustar tus prompts para que quepan en la ventana de contexto sin perder información clave. [web:83][web:99]

OpenAI explica que, antes de generar una respuesta, la API convierte tu texto en una lista de tokens, procesa esos tokens internamente y luego convierte los tokens resultantes de nuevo en palabras que ves en la salida. [web:89] Anthropic y otras plataformas ofrecen herramientas para contar tokens antes de enviar solicitudes, lo que facilita gestionar límites y costos. [web:83][web:99]

[Ilustración: Una frase corta, como “La IA generativa está transformando la educación”, dividida visualmente en bloques coloreados que representan tokens; debajo de cada bloque se indica el número de token (por ejemplo, Token 1, Token 2, etc.).] 

| Comparación     | Aprox. relación                         |
|-----------------|------------------------------------------|
| 1 token         | ≈ 4 caracteres (en inglés)               |
| 100 tokens      | ≈ 60–80 palabras                         |
| 2,048 tokens    | ≈ 1,500 palabras                         |

Dato relevante
En modelos modernos de gran capacidad, las ventanas de contexto pueden superar los cientos de miles de tokens, permitiendo trabajar con libros, repositorios de código completos o grandes conjuntos de documentos en una sola conversación. [web:80][web:96]

Conclusión de la sección: los tokens son la unidad básica de texto para un modelo de IA. Entender cómo se relacionan con palabras, costos y límites de contexto es esencial para diseñar prompts que sean eficientes y que quepan en las capacidades del modelo. [web:89][web:83]

2.3 El contexto

En el uso cotidiano de IA, hablamos de “contexto” para referirnos a toda la información que el modelo tiene disponible para interpretar un prompt y generar una respuesta. Anthropic define la ventana de contexto como “todo el texto que el modelo puede referenciar al generar una respuesta, incluyéndose a sí misma”. [web:74][web:75]

El contexto incluye:

  • El prompt actual (instrucciones, preguntas, ejemplos). [web:31]
  • El historial de conversación que hayas incluido (mensajes anteriores relevantes). [web:74]
  • Cualquier documento, código o información adicional que envíes como parte de la entrada. [web:75]

Cuanto más rico y relevante sea el contexto, más capacidad tendrá el modelo para producir respuestas alineadas con tus necesidades. Por el contrario, prompts con poco contexto obligan al modelo a “rellenar huecos” con suposiciones, lo que aumenta el riesgo de errores o respuestas genéricas. [web:31][web:68]

Veamos ejemplos:

| Tipo de contexto    | Prompt                               | Resultado típico                                |
|---------------------|--------------------------------------|------------------------------------------------|
| Poco contexto       | "Explica la teoría X"               | Respuesta genérica, sin conexión a tu uso real |
| Contexto adecuado   | "Explica la teoría X para docentes de secundaria, en 3 párrafos, destacando ejemplos prácticos en clase." | Respuesta adaptada a audiencia y formato       |
| Contexto extenso    | "Lee el siguiente programa de estudios y luego propone una actividad basada en la teoría X para la semana 3." + documento adjunto | Respuesta alineada con el programa concreto    |

Google Cloud enfatiza que el contexto es la clave para que el modelo entienda “quién eres”, “qué quieres lograr” y “qué información debe considerar” al generar la salida. [web:68] En sistemas como Claude Code, la ventana de contexto incluye no solo tus instrucciones, sino también los archivos que el modelo ha leído y sus propias respuestas anteriores; toda esa información forma parte del “estado” de la conversación. [web:75][web:78]

[Ilustración: Una línea de tiempo de conversación donde cada mensaje (del usuario y del modelo) se representa como un bloque. Los bloques relevantes están resaltados para indicar que forman parte del contexto enviado en la siguiente petición.]

Consejo
Cuando una respuesta sea insatisfactoria, pregúntate primero si el modelo tenía suficiente contexto. Muchas veces, añadir información relevante o un ejemplo claro mejora más el resultado que cambiar de modelo. [web:31][web:68]

Conclusión de la sección: el contexto es todo lo que el modelo “ve” al responder. Diseñar buenos prompts implica decidir qué parte de la información disponible debe entrar en esa ventana de contexto y cómo presentarla para que el modelo la entienda y la use correctamente. [web:74][web:75]

2.4 La ventana de contexto

La ventana de contexto es el límite máximo de tokens que un modelo puede considerar simultáneamente al generar una respuesta. Incluye tanto los tokens de entrada (prompt, historial, documentos) como los tokens de salida (respuesta generada). [web:89][web:91]

OpenAI explica que cada modelo tiene una longitud de contexto específica, y que la suma de tokens de tu prompt más los tokens que el modelo genera no puede superar ese límite. [web:89][web:91][web:93] Anthropic, por su parte, ha ampliado las ventanas de contexto de Claude hasta 100,000 tokens e incluso modelos experimentales con más, lo que permite trabajar con cientos de páginas de texto en una sola sesión. [web:80][web:96]

| Modelo (ejemplos)         | Ventana de contexto (aprox.)       | Uso típico                                      |
|---------------------------|-------------------------------------|------------------------------------------------|
| Modelos GPT clásicos      | Miles de tokens                     | Conversaciones y documentos moderados          |
| Claude con 100K contexto  | ~100,000 tokens                     | Libros, grandes repositorios, largos informes  |
| Claude Opus 4.6 (1M)      | ~1,000,000 tokens                   | Análisis de sistemas extensos, bases de código |

En la práctica, la ventana de contexto implica que:

  • Si tu entrada es demasiado larga, debes resumir, segmentar o seleccionar solo las partes relevantes para la tarea. [web:89][web:97]
  • Si quieres que el modelo “recuerde” una conversación larga, debes decidir qué partes mantener en el contexto y cuáles condensar en resúmenes. [web:75][web:96]
  • Para tareas complejas, puede ser útil reservar parte de la ventana para la salida, ajustando parámetros como max_tokens o max_output_tokens. [web:89][web:95]
graph LR
  A[Tokens de entrada] --> C[Ventana de contexto]
  B[Tokens de salida] --> C
  C --> D[Límite máximo por modelo]

En el diagrama, la ventana de contexto es la suma de tokens de entrada y salida; el diseño de prompts debe respetar ese límite. [web:89][web:91]

[Ilustración: Una barra horizontal dividida en dos colores: a la izquierda “Entrada” (prompt + historial) y a la derecha “Salida” (respuesta). La longitud total de la barra representa la ventana de contexto máxima de un modelo; se marcan ejemplos de cómo distribuir tokens entre entrada y salida.]

Error común
Enviar siempre toda la conversación o todo el documento al modelo sin considerar límites. Esto puede provocar errores, costos innecesarios o respuestas menos precisas por exceso de información irrelevante. [web:89][web:99]

Conclusión de la sección: la ventana de contexto es el espacio disponible para que el modelo considere información y genere respuestas. Diseñar prompts profesionales implica gestionar ese espacio: decidir qué entra, qué se resume y cuánto margen se deja para la salida. [web:74][web:80]

2.5 Temperatura

La temperatura es un parámetro que controla el grado de aleatoriedad en la selección de tokens durante la generación de texto. Google Cloud y otros proveedores explican que temperaturas bajas favorecen respuestas más deterministas y precisas, mientras que temperaturas altas producen respuestas más diversas y creativas. [web:79][web:86]

En términos simples:

  • Con temperatura baja (cercana a 0), el modelo tiende a elegir casi siempre el token con mayor probabilidad. Esto es útil para tareas técnicas, respuestas que deben ser consistentes y situaciones donde prefieres poco margen de creatividad. [web:84][web:86]
  • Con temperatura alta (cercana a 1 o superior), el modelo explora opciones menos probables, produciendo variedad y creatividad, pero también aumentando el riesgo de respuestas extrañas o menos precisas. [web:79][web:84]
| Temperatura | Comportamiento típico                     | Uso recomendado                                  |
|------------|--------------------------------------------|--------------------------------------------------|
| 0.0–0.3    | Alta precisión, baja diversidad            | Código, instrucciones técnicas, análisis riguroso|
| 0.4–0.7    | Equilibrio entre precisión y creatividad   | Explicaciones, resúmenes, propuestas moderadas  |
| 0.8–1.0+   | Alta diversidad, más creatividad y riesgo  | Brainstorming, ideas creativas, contenido libre  |

En la documentación de Gemini (Google), se indica que la temperatura por defecto suele ser 1.0 y que el rango aceptado va de 0.0 a 2.0, según el modelo. [web:79][web:86] Ajustar la temperatura es una forma poderosa de influir en el estilo de las respuestas sin cambiar el modelo ni el prompt de base.

[Ilustración: Cuatro versiones de la misma frase completada con distintas temperaturas. A temperatura baja, la frase se completa con un final esperado y técnico; a temperatura alta, con finales creativos o inesperados. La imagen subraya el efecto del parámetro en la variedad de la salida.]

Dato relevante
Algunas guías recomiendan temperaturas cercanas a 0 para tareas que requieren precisión (como análisis de código o explicación técnica) y temperaturas alrededor de 0.7–1 para tareas creativas como generación de ideas o borradores de texto. [web:84][web:86]

Conclusión de la sección: la temperatura no cambia “lo que sabe” el modelo, pero sí cómo elige entre las opciones posibles. Entender y ajustar este parámetro te permite controlar el equilibrio entre precisión y creatividad en las respuestas. [web:79][web:86]

2.6 ¿Qué son las alucinaciones?

En el contexto de IA, hablamos de “alucinaciones” cuando un modelo genera información que suena plausible pero es falsa, incoherente o no respaldada por los datos disponibles. Meta, OpenAI y otros actores señalan claramente esta limitación en la documentación de sus modelos: los LLM pueden inventar nombres, fechas, citas o detalles técnicos con gran seguridad aparente. [web:100][web:31]

Las alucinaciones ocurren porque el modelo está optimizado para producir texto que parezca coherente y fluido, no necesariamente para decir siempre la verdad. Al predecir el siguiente token, el sistema se basa en patrones aprendidos, no en una base de conocimiento validada en tiempo real (a menos que se combine con herramientas externas). [web:31][web:68]

Por qué aparecen

  • Falta de contexto suficiente: el modelo “rellena” huecos con suposiciones. [web:74][web:82]
  • Tareas mal definidas: prompts vagos o ambiguos que no especifican claramente la fuente de la información esperada. [web:31]
  • Limitaciones del entrenamiento: el modelo ha visto textos con errores o información no verificada y puede replicarlos. [web:100]

Cómo detectarlas

  • Verificar datos concretos (fechas, cifras, nombres) contra fuentes confiables externas.
  • Observar señales como respuestas demasiado genéricas, excesiva confianza en detalles que no puede justificar, o contradicciones internas. [web:31][web:68]

Cómo reducirlas

  • Proporcionar contexto verificable (documentos, extractos, datos) y pedir explícitamente que se limite a esa información. [web:68][web:82]
  • Formular prompts que incluyan instrucciones como “si no tienes suficiente información, indica que no puedes responder con certeza”. [web:31]
  • Combinar modelos con sistemas de recuperación de información (RAG) o bases de datos externas cuando el uso lo requiera. [web:31][web:68]
| Tipo de respuesta            | Características                           |
|------------------------------|-------------------------------------------|
| Respuesta verificada         | Basada en fuentes claras o contexto dado |
| Respuesta potencialmente correcta | Suena plausible pero requiere verificación |
| Alucinación                  | Detalles falsos o inventados sin respaldo|

[Ilustración: Dos columnas de texto. En la primera, una respuesta que cita un documento proporcionado y mantiene coherencia con los datos. En la segunda, una respuesta que incluye hechos inexistentes (como nombres de autores ficticios), resaltados en color para mostrar la alucinación.]

Error común
Tratar las respuestas del modelo como verdades absolutas sin verificación, especialmente en temas técnicos, científicos o sensibles. Esto puede llevar a decisiones incorrectas o contenido engañoso. [web:31][web:100]

Conclusión de la sección: las alucinaciones no son “fallos aislados”; son una consecuencia natural de cómo están diseñados los modelos. Aprender a reducirlas y a detectarlas es una parte esencial del trabajo profesional con IA, tanto al diseñar prompts como al evaluar resultados. [web:31][web:68]

2.7 Buenas prácticas

Con todo lo anterior, podemos extraer algunas buenas prácticas generales para aprovechar mejor la forma en que “piensan” los modelos de lenguaje al escribir prompts. [web:31][web:68]

1. Diseñar con el contexto en mente

Ten siempre presente que el modelo solo puede usar la información que está dentro de su ventana de contexto. Si quieres que tenga en cuenta un documento, programa, política o ejemplo, inclúyelo explícitamente o resume sus partes relevantes. [web:74][web:75]

2. Ajustar longitud y claridad

Usa un nivel de detalle suficiente para que la tarea esté bien definida, pero sin saturar el modelo con información irrelevante. Esto implica seleccionar, resumir y organizar el contenido antes de enviarlo. [web:89][web:95]

3. Controlar la temperatura según el objetivo

Para tareas técnicas, análisis o instrucciones precisas, utiliza temperaturas bajas. Para brainstorming, generación de ideas o contenido creativo, permite temperaturas más altas dentro de rangos razonables. [web:79][web:86]

4. Anticipar y gestionar alucinaciones

Diseña prompts que inviten al modelo a admitir la incertidumbre cuando la tenga y, cuando sea posible, proporciona fuentes explícitas. Siempre verifica las salidas en contextos críticos. [web:31][web:100]

5. Pensar en la ventana como recurso limitado

Considera la ventana de contexto como un “espacio de trabajo” con capacidad limitada. Decide qué quieres que “esté en la mesa” para que el modelo lo tenga en cuenta y qué puede quedar fuera o resumido. [web:74][web:80]

| Buena práctica                    | Beneficio principal                               |
|-----------------------------------|---------------------------------------------------|
| Diseñar con contexto              | Respuestas más relevantes y alineadas             |
| Ajustar longitud y claridad       | Menos errores y mejor uso de la ventana de contexto|
| Controlar temperatura             | Equilibrio entre precisión y creatividad          |
| Gestionar alucinaciones           | Mayor confiabilidad de las respuestas             |
| Pensar en la ventana como recurso | Uso eficiente de tokens y menor riesgo de truncado|

[Ilustración: Un “panel de control” imaginario con controles para contexto, temperatura y longitud, mostrando cómo ajustar cada uno según el tipo de tarea (técnica, creativa, analítica).]

Buenas prácticas
No te quedes solo en la teoría: cada vez que ajustes contexto, temperatura o longitud, observa cómo cambian las respuestas y documenta tus hallazgos en tu PromptBook. [web:31][web:40]

Conclusión de la sección: entender cómo funciona el modelo por dentro solo es útil si lo traducimos en decisiones concretas al escribir prompts. Estas buenas prácticas son el puente entre la teoría y la práctica profesional. [web:31][web:68]

2.8 Aplicación al PromptBook

En este capítulo vamos a extender tu PromptBook Profesional con una nueva sección dedicada a los fundamentos del comportamiento de los modelos. Esta documentación te ayudará a recordar conceptos clave y a compartir tu conocimiento con otras personas que utilicen tu PromptBook. [web:40]

Estructura propuesta

Dentro de tu carpeta PromptBook/, crea una nueva carpeta llamada Fundamentos/ con la siguiente estructura:

PromptBook/
  Fundamentos/
    Tokens.md
    Contexto.md
    Temperatura.md
    VentanaContexto.md
    Alucinaciones.md
    BuenasPracticas.md

Cada archivo será un documento breve (que podrás ampliar con el tiempo) donde describirás, en tus propias palabras, los conceptos que has aprendido:

  • Tokens.md: qué son los tokens, cómo se relacionan con palabras, costos y límites de los modelos. [web:89][web:83]
  • Contexto.md: qué es el contexto, cómo influye en las respuestas y ejemplos de uso. [web:74][web:75]
  • Temperatura.md: cómo afecta a la creatividad y precisión de las respuestas, con ejemplos de distintos valores. [web:79][web:86]
  • VentanaContexto.md: qué significa la ventana de contexto, límites aproximados de distintos modelos y estrategias para gestionarla. [web:74][web:80]
  • Alucinaciones.md: definición, ejemplos, estrategias para detectar y reducir alucinaciones en tu trabajo con IA. [web:31][web:100]
  • BuenasPracticas.md: síntesis de las recomendaciones que consideras más útiles para tu propio flujo de trabajo con prompts. [web:31][web:68]
graph TD
  PB[PromptBook] --> F[Fundamentos]
  F --> T[Tokens.md]
  F --> C[Contexto.md]
  F --> Temp[Temperatura.md]
  F --> V[VentanaContexto.md]
  F --> A[Alucinaciones.md]
  F --> BP[BuenasPracticas.md]

Este diagrama muestra cómo la carpeta Fundamentos/ se integra dentro del PromptBook y agrupa la documentación conceptual que respaldará tus decisiones de diseño de prompts. [web:40]

[Ilustración: Una carpeta digital etiquetada como “Fundamentos” dentro del PromptBook, con iconos que representan cada documento: un bloque de texto para Tokens, una lupa sobre un documento para Contexto, un termómetro para Temperatura, una barra de longitud para Ventana de contexto y un signo de advertencia para Alucinaciones.]

Nota
No busques escribir tratados extensos en cada archivo desde el primer día. Empieza con definiciones claras y ejemplos simples; podrás enriquecerlos a medida que tu experiencia crezca.

Conclusión de la sección: documentar estos fundamentos dentro de tu PromptBook convierte tu conocimiento en un recurso tangible, fácil de compartir y mejorar. No solo tendrás prompts, sino también una base conceptual que explica por qué están diseñados como están. [web:40]

Práctica guiada

Para cerrar el capítulo, te proponemos una serie de actividades que consolidan lo aprendido a través de tu PromptBook y de la observación directa de las respuestas de la IA.

1. Comparar respuestas con distinto contexto

  1. Diseña dos prompts para la misma tarea (por ejemplo, explicar un concepto técnico): uno con muy poco contexto y otro con contexto rico (audiencia, objetivo, ejemplos).
  2. Envía ambos a un mismo modelo y compara las respuestas.
  3. Anota en Contexto.md las diferencias más importantes y tus conclusiones sobre qué tipo de contexto funcionó mejor. [web:31][web:68]

2. Experimentar con niveles de detalle

  1. Toma un prompt que ya uses y crea una versión más detallada (añadiendo claridad, objetivo y formato).
  2. Compara los resultados y documenta en BuenasPracticas.md qué mejoras observaste al aumentar el nivel de detalle. [web:31]

3. Analizar ejemplos de alucinaciones

  1. Formula una pregunta sobre un tema técnico o histórico y, luego, verifica la respuesta del modelo contra fuentes confiables.
  2. Si detectas errores o información inventada, registra el ejemplo en Alucinaciones.md, explicando cómo podrías haber diseñado mejor el prompt para reducir el riesgo. [web:31][web:100]

4. Experimentar con temperatura

  1. Si tienes acceso a un modelo donde puedas ajustar temperatura, diseña un mismo prompt y ejecútalo con temperatura baja y alta.
  2. Compara las respuestas y documenta en Temperatura.md cuándo te fue útil cada configuración. [web:79][web:86]

5. Registrar conclusiones

  1. En VentanaContexto.md, escribe una breve reflexión sobre cómo piensas gestionar la ventana de contexto en tus proyectos (por ejemplo, resumiendo documentos largos o estableciendo límites claros para el historial de conversación). [web:74][web:80]

Buenas prácticas
Cada vez que experimentes con contexto, temperatura o longitud, piensa en tu PromptBook como un diario de laboratorio: registra lo que hiciste, lo que observaste y lo que aprendiste. Esto te permitirá crecer de forma sistemática y compartir tu experiencia con otras personas. [web:40]

Bibliografía

  • OpenAI. “What are tokens and how to count them?” Artículo de ayuda sobre tokens, longitud de contexto y reglas de cálculo. https://help.openai.com/en/articles/4936856-what-are-tokens-and-how-to-count-them [web:89]
  • OpenAI. “Controlling the length of OpenAI model responses.” Guía sobre control de longitud, costos y tokens de salida. https://help.openai.com/en/articles/5072518-controlling-the-length-of-openai-model-responses [web:95]
  • OpenAI. “Prompt engineering – strategies and tactics for better results using large language models.” Documentación oficial sobre diseño de prompts y uso del contexto. https://developers.openai.com/api/docs/guides/prompt-engineering [web:31]
  • Anthropic. “Context windows – Claude Platform Docs.” Guía sobre ventanas de contexto y su uso práctico en Claude. https://platform.claude.com/docs/en/build-with-claude/context-windows [web:74]
  • Anthropic. “Token counting – Claude Platform Docs.” Documentación sobre conteo de tokens y gestión de límites. https://platform.claude.com/docs/en/build-with-claude/token-counting [web:83]
  • Anthropic. “Prompt engineering for Claude’s long context window.” Artículo técnico sobre cómo aprovechar ventanas de contexto largas. https://www.anthropic.com/news/prompting-long-context [web:76]
  • Anthropic. “Introducing 100K Context Windows.” Anuncio y explicación de ventanas de contexto de 100,000 tokens. https://www.anthropic.com/news/100k-context-windows [web:80]
  • AIPaths Academy. “Claude’s Context Window: A Complete Guide.” Guía educativa sobre gestión práctica de contexto en Claude. https://www.aipaths.academy/en/docs/002_claude-context-window [web:82]
  • ClaudeImplementation. “Claude Token Management: Context.” Guía para ingenieros sobre gestión de tokens y contexto en entornos empresariales. https://claudeimplementation.com/blog/claude-token-management [web:99]
  • Milvus. “How does Claude Opus 4.5 track remaining tokens in long conversations.” Análisis técnico de ventanas de contexto extendidas. https://blog.milvus.io/ai-quick-reference/how-does-claude-opus-45-track-remaining-tokens-in-long-conversations [web:96]
  • Google Cloud. “Introduction to prompting – Generative AI on Vertex AI.” Documentación sobre diseño de prompts y uso del contexto. https://cloud.google.com/vertex-ai/generative-ai/docs/learn/prompts/introduction-prompt-design [web:68]
  • Google Cloud. “Experiment with parameter values – Generative AI on Vertex AI.” Guía sobre temperatura, Top-P y Top-K en modelos Gemini. https://cloud.google.com/vertex-ai/generative-ai/docs/learn/prompts/adjust-parameter-values [web:79][web:86]
  • Vertex AI Community. “Vertex AI Gemini Model’s configuration parameters: temperature, top-p, top-k.” Explicación detallada con ejemplos de selección de tokens. https://discuss.google.dev/t/vertex-ai-gemini-models-configuration-parameters-temperature-top-k-top-p/148566 [web:84]
  • Meta. “Llama inference code and limitations.” Repositorio y documentación técnica sobre modelos Llama y sus comportamientos. https://github.com/meta-llama/llama [web:100]
  • Dair.ai. “Prompt Engineering Guide.” Repositorio educativo con recursos sobre prompts, contexto y parámetros de generación. https://github.com/dair-ai/Prompt-Engineering-Guide [web:40]