Memoria de conversación en una ventana de 100k: presupuestación, recorte y resúmenes
Una ventana de 100.000 tokens parece enorme hasta que un roleplay o historia larga la llena. Este artículo trata el contexto como un libro mayor: apartas espacio para la respuesta, proteges un pequeño conjunto de datos fijos, resumi turnos antiguos en un resumen rotativo y recortas el resto. Cada paso viene con código Python corto que puedes adaptar.

ActualizadoUnfiltered AI
Puntos clave
- Proveedores de inferencia dedicados como Unfiltered AI ofrecen comportamiento sin censura consistente en un único modelo, evitando la aleatoriedad del enrutamiento de agregadores.
- Los agregadores como OpenRouter proporcionan acceso a múltiples modelos, pero pueden variar en la estrictitud de la aplicación de filtros de contenido dependiendo de la versión específica del modelo.
- Unfiltered AI utiliza un modelo de pesos abiertos en hardware dedicado con una ventana de contexto de 100k, con un precio de $0,15/$0,50 por millón de tokens.
- Para una consistencia estricta de NSFW o roleplay, una API LLM sin censura dedicada elimina la necesidad de ingeniería de prompts compleja para eludir filtros genéricos.
Piensa en la ventana como un libro mayor
El modelo no tiene memoria entre llamadas. Lo que parece recordar es que reenvías texto, y cada token reenviado es una línea en un libro mayor con un límite estricto: 100.000 tokens, compartido por el prompt and la respuesta. Gasta más en el prompt y dejas menos espacio para la respuesta; pide demasiado de ambos y la petición se rechaza con un 400.
Un libro mayor viable se ve así. Reserva 1.500 tokens para la respuesta, porque eso es lo que pasarás como max_tokens. Reserva otros 3.000 como margen, ya que cualquier recuento local de tokens es una estimación. Eso deja 59.500 tokens de presupuesto para el prompt. Dentro de ese presupuesto, compiten cuatro tipos de contenido: el prompt del sistema, datos fijos, un resumen rotativo y los turnos recientes literales. El resto de este artículo trata sobre decidir quién gana.
El orden de prioridad es simple de establecer. El contenido del sistema y el contenido fijo nunca se cortan. El resumen se reemplaza en lugar de cortarse. Los turnos recientes se cortan del más antiguo al más reciente. Todo lo que se elimina de los turnos recientes no se pierde, porque se consolida en el resumen primero.
Contar sin un tokenizer
Utiliza los recuentos de usage devueltos para verificar tus estimaciones. Un atajo basado en caracteres por token puede variar según el idioma, la puntuación y el código. Deja espacio para la salida y reduce la entrada cuando las estimaciones se acerquen al límite combinado del contexto.
Por eso existe el margen, y por qué vale la pena calibrar. Después de cada llamada, compara los caracteres que enviaste con usage.prompt_tokens y ajusta tu ratio hacia el valor observado. Un pequeño factor de suavizado evita que un mensaje extraño lo desajuste.
class Calibrator:
"""Learns the real chars-per-token ratio from the usage block."""
def __init__(self):
self.ratio = 4.0
def update(self, sent_messages, prompt_tokens):
chars = sum(len(m["content"]) for m in sent_messages)
if prompt_tokens > 0 and chars > 2000:
observed = chars / prompt_tokens
self.ratio = 0.8 * self.ratio + 0.2 * observed # smooth it
def est(self, text):
return int(len(text) / self.ratio) + 4Si cambias el est del calibrador en el recortador, el presupuesto se ajusta solo a medida que el carácter real de la conversación emerge. Una historia pesada en diálogos y palabras cortas tiende a costar más tokens por carácter que la prosa expositiva, por lo que la proporción observada vale la pena vigilar.
Recorte: primero los más recientes, nunca en medio de un par
Recorre el historial reciente hacia atrás y añade solo los mensajes que quepan en el presupuesto. Si incluso el intercambio más reciente es demasiado grande, trúncalo o recházalo deliberadamente. Mantén el contexto requerido y los roles permitidos en una secuencia válida; seleccionar turnos recientes no garantiza respuestas coherentes.
# memory.py
WINDOW = 64_000 # prompt + completion share this
MAX_OUT = 1_500 # what we ask for in max_tokens
MARGIN = 3_000 # slack for estimation error
BUDGET = WINDOW - MAX_OUT - MARGIN # 59,500 tokens for the prompt
def est_tokens(text: str) -> int:
# Rough heuristic: about 4 characters per token for English prose.
return len(text) // 4 + 4
def build_messages(system, pinned, summary, turns):
"""Return (messages_to_send, dropped_turns). turns is oldest-first."""
head = [{"role": "system", "content": system}]
if pinned:
head.append({"role": "system", "content": "Pinned facts (always true):\n- " + "\n- ".join(pinned)})
if summary:
head.append({"role": "system", "content": "Story so far: " + summary})
used = sum(est_tokens(m["content"]) for m in head)
kept = []
for m in reversed(turns): # walk from the newest turn backwards
cost = est_tokens(m["content"])
if used + cost > BUDGET:
break
kept.append(m)
used += cost
kept.reverse()
while kept and kept[0]["role"] != "user": # never start on an orphaned assistant turn
kept.pop(0)
dropped = turns[: len(turns) - len(kept)]
return head + kept, droppedLa función devuelve dos cosas: los mensajes para enviar y los turnos que salieron. Devolver los turnos eliminados, en lugar de descartarlos, es la decisión de diseño que hace posibles los resúmenes. Nada se elimina en silencio.
Fijar datos que deben sobrevivir
Un resumen es inherentemente con pérdidas. Los datos del personaje que nunca deben desviarse, como un nombre, un secreto, una promesa o una regla del mundo, no deben depender de que un resumenista elija mantenerlos. Almacénalos como una lista corta fuera del historial e inyéctalos como un mensaje del sistema dedicado en cada llamada.
- Fijar identidad: nombres, relaciones, especies, edad (solo adultos), ocupación.
- Fijar restricciones: cosas que el narrador no debe hacer o revelar aún.
- Fijar estado que cambia rara vez: ubicación, estación, quién tiene qué.
- No fijes el ambiente. El estado de ánimo pertenece al resumen, donde puede evolucionar.
Mantén el bloque fijado por debajo de aproximadamente 400 tokens. Si crece más allá de eso, comienza a comportarse como un segundo prompt del sistema y el modelo comienza a tratar cada línea fijada como igualmente urgente. Revisa la lista ocasionalmente y retira los datos que ya no son ciertos.
Resúmenes rotativos
Cuando los turnos caen fuera de la ventana, pide al modelo que los resuma en un resumen existente. El prompt importa más que el código: dígale qué mantener (quién está presente, qué cambió, promesas, hilos sin resolver, lugar actual) y qué descartar (relleno, descripción repetida), y limita la longitud en palabras. Un límite evita que el resumen se hinle lentamente hasta convertirse en el mismo problema que resuelve.
import os
from openai import OpenAI
client = OpenAI(base_url="https://api.unfilteredaiapi.com/v1", api_key=os.environ["API_KEY"])
SUMMARY_PROMPT = (
"Compress the material below into a running summary of at most 250 words. "
"Keep: who is present, what changed, promises and secrets, unresolved threads, "
"the current location and mood. Drop: filler and repeated description. "
"Write plain past-tense prose, no bullet points."
)
def fold_into_summary(old_summary, dropped_turns):
transcript = "\n".join(f"{m['role']}: {m['content']}" for m in dropped_turns)
user = f"Existing summary:\n{old_summary or '(none)'}\n\nNew material:\n{transcript}"
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "system", "content": SUMMARY_PROMPT}, {"role": "user", "content": user}],
temperature=0.2,
max_tokens=450,
)
return r.choices[0].message.content.strip()Usa una temperatura baja. Un resumen debe ser fiel, no inventivo. Una protección económica es leer el resumen tú mismo cada veinte o así compresiones durante el desarrollo; los errores se acumulan porque cada nuevo resumen se construye sobre el anterior.
Unir las piezas
La clase a continuación conecta el recorte, el fijado y el resumen en un solo bucle. Cada llamada construye el prompt, verifica si se eliminó algo, lo consolida en el resumen si es así, y lo reconstruye. La regla es intencionalmente perezosa: solo resume cuando la ventana lo obliga, así que las conversaciones cortas nunca pagan por una llamada de resumen.
from memory import build_messages, fold_into_summary, client, MAX_OUT
class Conversation:
def __init__(self, system, pinned):
self.system, self.pinned = system, pinned
self.summary, self.turns = "", []
def say(self, text):
self.turns.append({"role": "user", "content": text})
messages, dropped = build_messages(self.system, self.pinned, self.summary, self.turns)
if dropped: # something fell out of the window
self.summary = fold_into_summary(self.summary, dropped)
self.turns = self.turns[len(dropped):]
messages, _ = build_messages(self.system, self.pinned, self.summary, self.turns)
r = client.chat.completions.create(
model="uncensored", messages=messages, max_tokens=MAX_OUT, temperature=0.8
)
answer = r.choices[0].message.content
self.turns.append({"role": "assistant", "content": answer})
return answer
convo = Conversation(
system="You narrate a slow-burn adult mystery set in a mountain hotel.",
pinned=["Ines Duarte is the night manager and is lying about the ledger.",
"It is the third night of the blizzard; the road is closed.",
"The narrator never reveals the culprit before the player accuses someone."],
)
print(convo.say("I ask Ines why the guest book has a page missing."))Esto se empareja naturalmente con el relé de streaming en el artículo de backend FastAPI, donde la tienda de sesiones contendría summary, pinned y turns en lugar de una lista plana. Para el estado de NPC estructurado en el mismo patrón, consulta la guía de diálogo de juegos.
El coste de recordar
La memoria larga no es gratis, porque todo el prompt se factura de nuevo en cada llamada. Asume dos configuraciones. En la primera, se permite que el historial llene 50.000 tokens de prompt y cada respuesta es de 500 tokens. La entrada cuesta 50.000 x $0,15 / 1.000.000 = $0,0075, la salida cuesta 500 x $0,50 / 1.000.000 = $0,00025, así que cada turno cuesta unos $0,00775. En la segunda, mantienes 8.000 tokens de turnos recientes más un resumen de 600 tokens y 400 tokens fijos, unos 9.000 en total. La entrada es $0,00225, la salida $0,00025, así que cada turno es de cerca $0,0028.
En 1.000 turnos eso es aproximadamente $13 frente a $2,75 bajo estas suposiciones. El enfoque de resumen también cuesta una llamada extra ocasional de quizás 3.000 de entrada y 450 tokens de salida, unos $0,0012, que es insignificante frente al ahorro. Las tarifas están en la página de precios.
El consejo práctico: no llenes la ventana solo porque está ahí. Usa la ventana grande como seguro para los momentos en que una escena realmente necesite contexto literal largo, y deja que los resúmenes lleven el resto.
Dónde fallan silenciosamente los esquemas de memoria
Tres patrones de fallo se repiten una y otra vez. El primero es el desplazamiento del resumen: un detalle se parafrasea, la paráfrasis se resume de nuevo y, tras una docena de resúmenes, el hecho original resulta irreconocible. El anclaje es la cura para cualquier cosa que no puedas permitirte perder, y un límite estricto de palabras impide que el resumen lo absorba todo.
El segundo es el precipicio. Con un recorte puro y sin resumen, el turno más antiguo simplemente desaparece y el personaje de repente olvida algo que sabía hace un momento. Los usuarios notan. Ejecutar el resumenista un paso antes de que la ventana lo obligue, por ejemplo cuando el prompt pasa cerca del 80 por ciento del presupuesto, suaviza la transición.
El tercero es la confusión de roles después del recorte, cuando el historial comienza en medio de un intercambio. La verificación de asistente inicial en el recortador existe para esto. Añade una prueba que construya una conversación falsa larga, la recorte, y afirme que el primer mensaje conservado es del usuario y que el total estimado se mantiene bajo presupuesto. Toma cinco minutos y previene una clase de errores difíciles de detectar en la reproducción manual.
Preguntas y respuestas
¿Qué ocurre si el prompt más max_tokens supera los 100.000?
La solicitud no se rechaza: max_tokens se ajusta al espacio disponible en la ventana y la respuesta se detiene al final de la ventana. Solo un prompt de más de 100.000 tokens devuelve un error 400 bad request.
¿Puedo contar tokens con exactitud antes de una petición?
No exactamente por adelantado. Estímate localmente, mantén un margen de seguridad y calibra contra el valor de usage.prompt_tokens devuelto con cada respuesta.
¿Con qué frecuencia debo resumir?
Solo cuando los turnos caen fuera de la ventana. Eso mantiene las conversaciones cortas libres de llamadas extra.
¿Se facturan los hechos fijos y los resúmenes?
Sí. Todo lo que envías como token de prompt se factura a $0,15 por millón de tokens de entrada en cada llamada, así que mantén ambos compactos.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la URL base. Eso es toda la configuración.