Estrategias para mantenerse dentro del contexto
Implementará memoria de ventana deslizante, resumen de mensajes y recorte selectivo del contexto para gestionar conversaciones largas sin superar los límites de tokens.
Estrategias para mantenerse dentro del contexto es una lección gratuita de AI Engineering Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Engineering Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Engineering Academy incluye 4 lecciones en total.
El creciente problema de las conversaciones
Cada mensaje intercambiado en una conversación de chat aumenta la cantidad de tokens de la siguiente llamada a la API. En una sesión larga de atención al cliente o de programación de varias horas, el historial acumulado de la conversación puede superar fácilmente los 20.000-50.000 tokens; todos ellos deben enviarse a la API en cada turno, y se vuelve a pagar repetidamente por tokens que ya se procesaron.
Sin una estrategia de gestión del contexto, su aplicación alcanzará el límite de contexto y fallará, o terminará truncando mensajes silenciosamente, lo que hará que el modelo pierda el hilo de información importante del contexto anterior. Toda aplicación LLM en producción necesita una estrategia explícita para gestionar el crecimiento del contexto.
Estrategia 1: ventana deslizante (últimos N mensajes)
La estrategia más sencilla consiste en conservar únicamente los últimos N mensajes del contexto y descartar los anteriores. Esto se denomina ventana deslizante. Es fácil de implementar, permite prever los costes y resulta suficiente para muchos casos de uso en los que el contexto reciente es más importante que los intercambios anteriores.
import openai
client = openai.OpenAI()
class SlidingWindowConversation:
def __init__(self, system_prompt, window_size=10):
self.system = system_prompt
self.window_size = window_size
self.history = []
def chat(self, user_message):
self.history.append({'role': 'user', 'content': user_message})
# Keep only the last N messages
windowed = self.history[-self.window_size:]
messages = [{'role': 'system', 'content': self.system}] + windowed
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=messages
)
reply = response.choices[0].message.content
self.history.append({'role': 'assistant', 'content': reply})
print(f'Context: {len(windowed)} messages ({len(self.history)} total)')
return reply
conv = SlidingWindowConversation('You are a helpful assistant.', window_size=6)
print(conv.chat('Hello! My name is Alice.'))
print(conv.chat('What is the capital of France?'))
print(conv.chat('What is my name?')) # Might forget if window is smallEstrategia 2: recorte teniendo en cuenta los tokens
En lugar de recortar según el número de mensajes, el recorte teniendo en cuenta los tokens elimina mensajes hasta que la cantidad total de tokens queda por debajo de un umbral. Es más preciso porque la longitud de los mensajes puede variar mucho: un límite de cantidad de mensajes podría incluir 10 mensajes cortos o 3 muy largos, con costes de tokens muy diferentes.
import tiktoken
def trim_to_token_budget(
messages, system_prompt, model='gpt-4o-mini', max_input_tokens=8000
):
enc = tiktoken.encoding_for_model(model)
def count(msgs):
return sum(len(enc.encode(m.get('content',''))) + 4 for m in msgs) + 3
# System prompt token count
system_tokens = len(enc.encode(system_prompt)) + 4
budget = max_input_tokens - system_tokens
# Trim from the oldest messages until we fit
trimmed = list(messages)
while trimmed and count(trimmed) > budget:
trimmed.pop(0) # Remove oldest message
removed = len(messages) - len(trimmed)
if removed:
print(f'Trimmed {removed} old messages to stay within {max_input_tokens} tokens')
return trimmedEstrategia 3: resumir la conversación
El resumen comprime los turnos antiguos de la conversación en un resumen conciso que conserva los datos clave, las decisiones y el contexto mencionados por el usuario. Es más sofisticado que las ventanas deslizantes porque conserva la esencia de los intercambios anteriores en lugar de descartarlos sin más.
El patrón funciona de la siguiente manera: cuando la conversación supera un umbral, envíe los N turnos más antiguos al modelo con el prompt «Resuma la conversación hasta este momento», sustituya esos turnos por un único mensaje de sistema que contenga el resumen y continúe la conversación con el nuevo historial comprimido.
import openai
client = openai.OpenAI()
def summarize_conversation(messages_to_summarize, model='gpt-4o-mini'):
summary_prompt = [
{'role': 'system', 'content': 'You summarize conversations. Be concise but preserve key facts, decisions, and any specific information the user shared (names, numbers, preferences).'},
{'role': 'user', 'content': 'Summarize this conversation:\n' + '\n'.join(
f"{m['role'].upper()}: {m['content']}" for m in messages_to_summarize
)}
]
resp = client.chat.completions.create(model=model, messages=summary_prompt, max_tokens=500)
return resp.choices[0].message.content
def compress_history(history, keep_recent=4):
if len(history) <= keep_recent:
return history
to_summarize = history[:-keep_recent]
summary = summarize_conversation(to_summarize)
summary_msg = {'role': 'system', 'content': f'Earlier conversation summary: {summary}'}
return [summary_msg] + history[-keep_recent:]
print('Summarization strategy compresses old turns into a single summary message')Estrategia 4: memoria de entidades
La memoria de entidades extrae y mantiene una representación estructurada de los datos clave mencionados en la conversación —preferencias del usuario, nombres, detalles del proyecto y decisiones tomadas— en lugar de almacenar el historial de mensajes sin procesar. Antes de cada turno, los datos almacenados se incorporan al prompt de sistema.
Esto usa menos tokens que el historial completo porque solo incluye lo que es semánticamente importante, no todas las palabras de cada turno. La memoria de entidades funciona especialmente bien para asistentes de larga duración, en los que los usuarios hacen referencia a preferencias y datos establecidos mucho antes en la conversación.
import openai
import json
client = openai.OpenAI()
def extract_entities(messages, model='gpt-4o-mini'):
prompt = [
{'role': 'system', 'content': 'Extract key facts from this conversation as JSON: {"user_name": null, "preferences": [], "key_facts": []}'},
{'role': 'user', 'content': '\n'.join(f"{m['role']}: {m['content']}" for m in messages)}
]
resp = client.chat.completions.create(
model=model,
messages=prompt,
response_format={'type': 'json_object'}
)
return json.loads(resp.choices[0].message.content)
conversation = [
{'role': 'user', 'content': 'Hi, I am Alice and I prefer Python over JavaScript.'},
{'role': 'assistant', 'content': 'Great to meet you, Alice! Python is an excellent choice.'},
{'role': 'user', 'content': 'I am building a REST API for my e-commerce startup.'}
]
entities = extract_entities(conversation)
print(json.dumps(entities, indent=2))Cuándo aplicar cada estrategia
Elija la estrategia según las características de su aplicación:
- Ventana deslizante: aplicaciones de chat sencillas en las que solo importa el contexto reciente y los usuarios no hacen referencia a intercambios antiguos. Es la opción más barata de implementar.
- Recorte teniendo en cuenta los tokens: cualquier aplicación en producción en la que la longitud de los mensajes varíe considerablemente. Siempre es mejor que recortar según el número de mensajes.
- Resumen: asistentes de larga duración, sesiones de atención al cliente y bots de gestión de proyectos. Los usuarios esperan que el asistente recuerde datos clave de intercambios ocurridos horas antes.
- Memoria de entidades: asistentes personales, chatbots que tienen en cuenta las preferencias del usuario y sistemas de tutoría en los que el perfil del usuario es importante durante toda la sesión.
Estas estrategias también pueden combinarse: use la memoria de entidades para los datos fundamentales y una ventana deslizante para la conversación reciente.
RAG como alternativa a introducir todo el contexto
En aplicaciones con un gran volumen de conocimiento, la mejor estrategia de gestión del contexto consiste en no incluir los documentos en el contexto; en su lugar, use RAG (Retrieval-Augmented Generation) para recuperar únicamente los fragmentos específicos relevantes para la consulta actual. Esto mantiene el contexto centrado, reduce los costes y suele producir mejores respuestas que insertar un documento completo.
La idea clave es que las ventanas de contexto largas resuelven el problema de «¿cabe?», pero no el de «¿lo utilizará bien el modelo?». Una recuperación precisa aborda ambos problemas al proporcionar al modelo únicamente la información que necesita para la pregunta actual.
Gestionar correctamente los errores de contexto máximo
A pesar de sus esfuerzos, puede encontrar errores de límite de contexto en producción, especialmente debido a contenido generado por usuarios que resulta inesperadamente largo. Gestione siempre de forma explícita el error context_length_exceeded, en lugar de dejar que llegue al usuario como una excepción no gestionada.
import openai
import tiktoken
client = openai.OpenAI()
def chat_with_context_guard(messages, model='gpt-4o-mini', max_tokens=100000):
enc = tiktoken.encoding_for_model(model)
total = sum(len(enc.encode(m.get('content',''))) + 4 for m in messages) + 3
while total > max_tokens and len(messages) > 2:
# Remove the second message (keep system prompt)
removed = messages.pop(1)
total -= len(enc.encode(removed.get('content',''))) + 4
print(f'Trimmed a message. New total: {total} tokens')
try:
return client.chat.completions.create(model=model, messages=messages)
except openai.BadRequestError as e:
if 'context_length' in str(e):
return {'error': 'Message history too long. Please start a new conversation.'}
raiseConservar el contexto entre sesiones
En una aplicación real, los usuarios cierran y vuelven a abrir la aplicación. El servidor se reinicia. La gestión del contexto debe tener en cuenta la persistencia entre sesiones, no solo dentro de una única sesión. Esto implica almacenar el historial de la conversación en una base de datos y cargarlo al inicio de cada sesión.
Un patrón razonable consiste en almacenar el historial completo sin procesar en PostgreSQL para fines de auditoría y ajuste fino, pero, al cargar el contexto para una nueva llamada a la API, aplicar la estrategia de resumen o recorte para ajustarlo al presupuesto de tokens. De este modo, nunca pierde datos, pero tampoco paga por el historial completo en cada solicitud.
Supervisar el crecimiento del contexto en producción
Registre la cantidad de tokens de cada llamada a la API y realice su seguimiento a lo largo del tiempo por ID de conversación. Una conversación saludable debería mostrar un crecimiento gradual seguido de una estabilización, a medida que se aplican los resúmenes. Una conversación que crece sin límite hasta alcanzar el límite de contexto indica que la lógica de recorte no funciona correctamente.
Supervise también la longitud media del contexto de todas las conversaciones. Si aumenta con el tiempo, puede indicar que el prompt de sistema predeterminado está creciendo debido a la incorporación de funcionalidades, que los usuarios están pegando entradas más largas o que RAG está devolviendo fragmentos cada vez más grandes. Cada una de estas situaciones requiere una solución diferente.
Combinar estrategias: un patrón para producción
Un sistema sólido de gestión del contexto en producción combina varias estrategias por capas:
- Antes de ensamblar el contexto: compruebe el presupuesto de tokens y regístrelo
- Aplicar la extracción de entidades: incorpore un bloque de memoria estructurada con los datos clave
- Añadir el historial reciente: incluya literalmente los últimos 6-10 mensajes
- Resumir el historial antiguo: si existe historial antiguo, incorpore un resumen acumulativo
- Comprobación de seguridad: si el total sigue superando el presupuesto, recorte los mensajes literales más antiguos
Este enfoque por capas conserva la información más importante (la memoria de entidades y el contexto reciente), mientras degrada gradualmente el historial antiguo, primero en forma de resúmenes y después mediante el recorte únicamente como último recurso.
Comprobación rápida
Compruebe su comprensión de los conceptos de ingeniería de IA de esta lección.
Resumen de la lección
En esta lección ha aprendido que las ventanas deslizantes y el recorte teniendo en cuenta los tokens son estrategias sencillas que descartan el contexto antiguo para mantenerse dentro de los límites, que el resumen comprime los turnos antiguos en una representación compacta que conserva los datos clave y que la memoria de entidades extrae datos estructurados para ofrecer una memoria a largo plazo eficiente en tokens a lo largo de una conversación. A continuación, exploraremos cómo conseguir que los LLM devuelvan JSON fiable mediante el modo JSON y las salidas estructuradas.
Preguntas frecuentes
¿La lección «Estrategias para mantenerse dentro del contexto» es gratis?
Sí — el texto completo de «Estrategias para mantenerse dentro del contexto» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Engineering Academy, actualiza a CoddyKit PRO. El curso de AI Engineering Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Estrategias para mantenerse dentro del contexto»?
Implementará memoria de ventana deslizante, resumen de mensajes y recorte selectivo del contexto para gestionar conversaciones largas sin superar los límites de tokens. Practicas AI Engineering Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar AI Engineering Academy?
No se requiere experiencia previa. AI Engineering Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Estrategias para mantenerse dentro del contexto»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de AI Engineering Academy?
Sí. Cada lección de AI Engineering Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- ¿Qué es un token?
- Ventanas de contexto: tamaño e implicaciones
- Cálculo y predicción de costes de la API
- Estrategias para mantenerse dentro del contexto