Skip to content

Sistema de memoria simple: deja que Jev decida qué recordar ​

💡 Resumen en una frase: usa Jev para construir un sistema de memoria de IA — una Noul compuerta decide qué recordar, las memorias se guardan en un diccionario de Python normal, y antes de cada llamada se integran automáticamente en el state.

Cada solicitud Jev solo ve el state que le envías. Lo que el cliente te dijo el mes pasado — qué versión usa, qué plan, si firmó contrato — no está en la siguiente solicitud, a menos que tu código lo ponga ahí.

El enfoque del cookbook oficial (Simple memory system) es muy directo: una solicitud Jev adicional por llamada, más un diccionario de Python.

Su escenario de ejemplo es el enrutamiento de tickets de soporte. En agosto (mes 8), el cliente dice que se autohospedan en Windows Server; en septiembre (mes 9), escriben «Dashboards have been really slow since this morning». Sin memoria, Jev envía ese ticket al equipo de nube; con memoria, los seis tickets posteriores se enrutan todos al equipo esperado — cada uno enrutado por separado, y solo tres de ellos aprovechan la memoria.

Este sistema de memoria de IA tiene solo dos componentes:

  • Después de la llamada: Jev mira la solicitud original y su propia respuesta, y contesta una Noul — oficialmente llamada the gate (la compuerta): ¿esta solicitud declara un hecho del cliente digno de recordar? Si P(yes) ≥ 0.5, el ticket junto con la respuesta se guarda como memoria de ese cliente
  • Antes de la llamada: añade al state los tickets ya guardados de ese cliente (con las respuestas de Jev) — envuelto en ask_with_memory(), con los mismos parámetros y valor de retorno que ask()
text
ask_with_memory(state, questions)
      │
      ▼  ① state + memorias ya guardadas de ese cliente (si no hay, se envía tal cual)
  Jev solicitud 1: responde tu pregunta (en este ejemplo: qué equipo debe atender este ticket)
      │  ② solicitud original + respuesta de Jev, emparejadas
      ▼
  Jev solicitud 2: la compuerta (una Noul) — ¿esta solicitud declara un hecho del cliente digno de recordar?
      │
      ▼  ③ ¿P(yes) ≥ REMEMBER_AT (0.5)? — tu código decide
 Sí ──┤── No ──┐
 ▼               │
 Guardar en MEMORIES    │
 (una lista por cada ID de cliente)
 └──────┬────────┘
        ▼
  ④ la respuesta de la solicitud 1 se devuelve tal cual, tu código actúa como siempre
        ↺  las memorias guardadas entran en la siguiente solicitud de ese cliente (volver a ①)

ask_with_memory() Esta función envolvente es un agent harness mínimo. Definición oficial: un harness es el código alrededor del modelo que le da capacidades adicionales (tool calls, ejecución en bucle). El harness de esta página solo aporta memoria — un diccionario de Python normal, una lista por cada ID de cliente. Para ver un harness que añade tool calls al modelo, ve a la lección anterior Decisiones de Agent.

Esta lección dura unos 15 minutos. Todos los números de esta página provienen de los datos grabados del cookbook oficial (jev-1.14.0, 2026-10-29): los archivos oficiales grabados, tras deduplicar, suman 31 llamadas y 21,456 tokens de entrada en total — a $42/Btok con salida gratuita, unos $0.0009. Los archivos grabados se publican con el repositorio oficial, y se pueden reproducir y verificar sin ninguna key.

Qué podrás hacer al terminar ​

  • Añadir memoria a cualquier sistema de «Jev juicio + historial del cliente»: tras cada llamada, una Noul compuerta decide si conviene recordar; antes de la llamada, las memorias guardadas se integran en el state — ask_with_memory() tiene los mismos parámetros y valor de retorno que ask(), se sustituye sin cambiar el resto del código
  • Convertir «qué recordar» en una pregunta explícita (GATE) en lugar de reglas dispersas: los hechos persistentes como versión, plan y contrato se guardan con 0.96–0.98; el teléfono del aeropuerto y el día festivo, con 0.02 y 0.03, no se guardan
  • Reproducir con tus manos la prueba oficial: con la misma frase «el dashboard va muy lento», el Jev puro lo enruta al equipo de nube con 0.55, y con memoria llega al equipo de autohospedaje en Windows con 0.98 — los seis tickets posteriores pasan de 3/6 a 6/6
  • Explicar los cinco límites de este sistema (dos solicitudes en serie por llamada, la memoria solo crece y nunca se reduce…), y conocer el siguiente paso oficial para mejorar la memoria (selección por relevancia, sustitución de memorias antiguas, cambio de base de datos)

Por qué usar Jev, en lugar de meter todo el historial en el prompt ​

CapacidadMeter todo en el prompt / dejar que el modelo de chat recuerde soloJev Memoria con compuerta
quién decide qué se recuerda❌ Guardar todo en la base: el móvil en el aeropuerto y los días festivos también ocupan contexto; que un modelo de chat recuerde: qué se recuerda depende del humor del modelo y la salida no se puede auditar✅ Una compuerta Noul da probabilidades: lo que debe recordarse 0.96–0.98, lo que no ≤ 0.04, el umbral está en tu código
¿Son fiables las probabilidades?❌ Pedirle al modelo que escriba su certeza en texto y rezar por que el análisis no falle✅ Entrenamiento de calibración RLCD: las probabilidades se alinean con resultados reales; la línea de P ≥ 0.5 solo así tiene sentido
cuando el historial crece❌ Cada petición carga con todo el historial, los token suben linealmente con el número de tickets✅ Solo los tickets que pasan la compuerta entran en la memoria; el state crece con los «hechos que vale la pena recordar»; cada llamada añade una única petición de compuerta fija
integrarlo en el código existente❌ Cambiar plantillas de prompt y la cadena de llamadas✅ ask_with_memory() tiene los mismos parámetros y valores de retorno que ask(): palabras textuales oficiales: al cambiarla no hay que tocar el resto del código
qué mira la compuerta❌ Recordar también las respuestas del modelo: las respuestas genéricas aplastan los hechos reales de la petición✅ Solo cuenta lo que escribieron el cliente o el personal de soporte en la petición; los hechos que solo aparecen en la respuesta no se guardan

Tu dilema actual ​

  • «El cliente dejó claro en 8 que se autoaloja en Windows Server; en 9, cuando el panel se ralentizó, el ticket se asignó de nuevo al equipo de nube: el cliente tuvo que explicar su entorno desde cero cada vez»
  • «Pedí a un modelo de chat que ayudara a “recordar la información del cliente”, y lo que devuelve no se puede auditar: a veces trata “hoy escribí desde el móvil en el aeropuerto” como un hecho a largo plazo, y a veces vuelve a registrar su propia inferencia de la ronda anterior»
  • «Intenté meter todo el historial de tickets en cada petición: los token se consumen cada vez más y el enrutamiento se desvía por tickets antiguos irrelevantes»

Cuándo usar esta técnica ​

Cuando necesitas:

  • Tu sistema ya usa Jev para decidir (enrutamiento, clasificación, verificación) y la calidad de la decisión depende de «quién es este cliente»: versión, sistema operativo, plan, contrato, preferencias a largo plazo
  • «Qué recordar» es una pregunta explícita más un umbral explícito: auditable por personas, versionable en el repositorio y reajustable en cualquier momento
  • Una memoria independiente por cliente, incluida automáticamente en las nuevas llamadas, sin cambiar ni una palabra de la pregunta

Y no quieres:

  • Meter todo el historial en cada petición, con token que suben linealmente con el historial
  • Dejar que un modelo de chat «recuerde» libremente y luego analizar el texto que escupe
  • Introducir para esto todo un pipeline de recuperación por embeddings: solo hace falta cuando la memoria crece (ver técnicas avanzadas)

🎒 Preparativos antes de empezar ​

  • Has completado Noul de sí/no: la compuerta es un Noul; 0–1 cómo leer la probabilidad y fijar el umbral, esta página lo usa directamente
  • Sabes que state es todo lo que Jev ve: la memoria es solo una clave más en el state, la pregunta no tiene que cambiar
  • Has logrado ejecutar instalación y primera petición: en .venv está typesafe-sdk, y TYPESAFE_API_KEY está en las variables de entorno
  • Descarga la caché oficial grabada: typesafe-public-examples, el json_cache.json del directorio cookbooks/basic_memory del repositorio, colócalo en el directorio de ejecución: al ejecutarlo tal cual el código oficial, no necesitas ni una key; si lo borras, todo va por llamadas reales
  • Conoce el límite de coste: la grabación oficial, tras la deduplicación, son 31 llamadas y 21,456 token de entrada; a $42/Btok son unos $0.0009, la salida es gratis: las tarifas están en modelos y precios

Hazlo conmigo ​

Paso 1: prepara el entorno, la caché oficial y cinco tickets tempranos ​

Por qué: el sistema de memoria necesita dos tipos de tickets: tickets tempranos que enuncian hechos persistentes (que deben recordarse) y mensajes posteriores que solo hablan del momento presente (que se benefician de la memoria). Todos los datos oficiales están escritos a mano para este ejemplo: 2 clientes, 5 tickets tempranos y 3 mensajes posteriores.

Crea el directorio, descarga la caché oficial grabada e instala las dependencias:

bash
mkdir jev-memory && cd jev-memory
curl -sLO https://raw.githubusercontent.com/typesafe-ai/typesafe-public-examples/main/cookbooks/basic_memory/json_cache.json
pip install ipython 'cooksafe>=0.2.0,<0.3.0' typesafe-sdk

La línea pip oficial originalmente no incluía typesafe-sdk (la plataforma de documentación lo trae preinstalado); aquí lo añadimos.

Celda de Setup (tal cual la oficial; make_playground_link y display no se usan hasta la última celda del Playground):

python
import json
import os
from pathlib import Path

from cooksafe import JsonCache, make_playground_link
from IPython.display import Markdown, display
from typesafe_sdk import Choice, Noul, NoulCriteria, SystemOneResponse, TypeSafeClient

TYPESAFE_MODEL = "jev-1.14.0"
REMEMBER_AT = 0.5  # save when P(lasting customer fact) reaches this starting threshold
MEMORY_KEY = "earlier_tickets_from_this_customer"  # where saved tickets go in the state

client = TypeSafeClient(
    api_key=os.environ.get("TYPESAFE_API_KEY", "cache-only"),  # keyless kernels replay the cache
    base_url=os.environ.get("TYPESAFE_ENDPOINT"),
    timeout=120.0,
)
json_cache = JsonCache(Path("json_cache.json"))

Las tres constantes se ocupan cada una de una cosa: TYPESAFE_MODEL fija la versión (la grabación oficial usa los números de jev-1.14.0); REMEMBER_AT = 0.5 es el umbral inicial para guardar memoria en la compuerta; MEMORY_KEY es el nombre de clave usado al colocar la memoria en el state. "cache-only" es el valor por defecto que la documentación oficial deja para la key: cuando la caché acierta no se envía ninguna petición, así que se pueden reproducir todos los números de esta página sin ninguna key.

Dos clientes, cinco tickets tempranos y tres mensajes posteriores (DATA oficial tal cual; expected_team está anotado a mano según lo que cada cliente dijo en sus tickets tempranos):

python
DATA = {
    "customers": {
        "C-1042": {"id": "C-1042", "company": "Acme Corp"},
        "C-2210": {"id": "C-2210", "company": "Example Studio"},
    },
    "earlier_tickets": [
        {"id": "T-101", "customer_id": "C-1042", "received_on": "2026-08-04",
         "subject": "Adding an admin",
         "text": "Hi, we run your self-hosted edition on Windows Server 2022 in our own data "
                 "centre. How do I add a new admin user?"},
        {"id": "T-102", "customer_id": "C-2210", "received_on": "2026-08-11",
         "subject": "Exporting to PDF",
         "text": "We're a small design studio on your cloud edition, paying monthly on the "
                 "self-serve Team plan. How do I export a dashboard as a PDF?"},
        {"id": "T-103", "customer_id": "C-1042", "received_on": "2026-08-19",
         "subject": "Invoice download",
         "text": "Sorry for the typos, typing this on my phone at the airport. Where can I "
                 "download last month's invoice?"},
        {"id": "T-104", "customer_id": "C-2210", "received_on": "2026-09-02",
         "subject": "Dark mode?",
         "text": "Our whole team is out on Friday for a public holiday, so no rush on this "
                 "one. Is there a dark mode?"},
        {"id": "T-105", "customer_id": "C-1042", "received_on": "2026-09-10",
         "subject": "Sandbox environment",
         "text": "For context, we signed an Enterprise contract with you in March. Can we get "
                 "a sandbox environment for testing?"},
    ],
    "later_messages": [
        {"subject": "Slow dashboards",
         "text": "Dashboards have been really slow since this morning."},
        {"subject": "Upgrade failing",
         "text": "The upgrade to version 5.2 keeps failing halfway through."},
        {"subject": "More seats",
         "text": "We'd like to add 20 more seats before next quarter."},
    ],
    "later_received_on": "2026-09-28",
    # Labelled by hand from what each customer said in the earlier tickets.
    "expected_team": {
        "C-1042": {"Slow dashboards": "selfhosted_windows",
                   "Upgrade failing": "selfhosted_windows", "More seats": "enterprise_desk"},
        "C-2210": {"Slow dashboards": "cloud_ops", "Upgrade failing": "cloud_ops",
                   "More seats": "billing"},
    },
}
CUSTOMERS = DATA["customers"]


def ticket_state(customer_id: str, ticket_id: str, received_on: str, subject: str,
                 text: str) -> dict:
    """The state Jev sees for one ticket: a simplified ticket, like one from a helpdesk."""
    return {
        "customer": CUSTOMERS[customer_id],
        "ticket": {
            "id": ticket_id,
            "received_on": received_on,
            "subject": subject,
            "messages": [{"from": "customer", "text": text}],
        },
    }


EARLIER = [
    ticket_state(t["customer_id"], t["id"], t["received_on"], t["subject"], t["text"])
    for t in DATA["earlier_tickets"]
]
print(f"{len(CUSTOMERS)} customers, {len(EARLIER)} earlier tickets, "
      f"{len(DATA['later_messages'])} later messages. The first ticket as Jev sees it:\n")
print(json.dumps(EARLIER[0], indent=2))

Deberías ver (publicación oficial):

text
2 customers, 5 earlier tickets, 3 later messages. The first ticket as Jev sees it:

{
  "customer": {
    "id": "C-1042",
    "company": "Acme Corp"
  },
  "ticket": {
    "id": "T-101",
    "received_on": "2026-08-04",
    "subject": "Adding an admin",
    "messages": [
      {
        "from": "customer",
        "text": "Hi, we run your self-hosted edition on Windows Server 2022 in our own data centre. How do I add a new admin user?"
      }
    ]
  }
}

El state de cada ticket tiene solo dos partes (ensamblado por ticket_state()): customer es quién reporta y ticket es un hilo de ticket simplificado. La intención del diseño de los datos la oficial la explica con claridad: tres tickets tempranos enuncian hechos persistentes: T-101 versión (autoalojado en Windows Server), T-102 plan (Team autoservicio en la nube), T-105 contrato (Enterprise); dos no enuncian: T-103 móvil en el aeropuerto, T-104 día festivo. Los tres mensajes posteriores no mencionan el entorno del cliente, así que sin memoria Jev solo puede adivinar.

  • 2 customers, 5 earlier tickets, 3 later messages se imprime sin errores; puedo señalar cuáles tres enuncian hechos persistentes y cuáles dos no

Paso 2: primero ejecuta el enrutamiento Jev puro, para ver dónde falla sin memoria ​

Por qué: primero establece la línea base: sin memoria, a dónde se enruta este ticket de «panel lento».

La pregunta de enrutamiento es un Choice; 7 opciones cubren 7 equipos de soporte. Fíjate en none_suitable: la documentación oficial le anota su uso: el destino cuando ningún equipo encaja; los tickets con contexto insuficiente caen aquí:

python
ROUTE = {
    "team": Choice(
        instructions="Which support team should handle `ticket`?",
        criteria={
            "cloud_ops": "Cloud team: problems with the hosted cloud edition, run by us",
            "selfhosted_linux": "Self-hosted team, Linux: installs, upgrades and "
            "performance of the self-hosted edition on Linux servers",
            "selfhosted_windows": "Self-hosted team, Windows: installs, upgrades and "
            "performance of the self-hosted edition on Windows Server",
            "billing": "Billing: invoices, payments, seats and plan changes for "
            "self-serve plans",
            "enterprise_desk": "Enterprise desk: seats, contracts and account changes for "
            "customers on an Enterprise contract (their technical problems go to the "
            "technical teams)",
            "general": "General product questions: features, how-to, settings",
            "none_suitable": "None of these teams fits the ticket",
        },
    ),
}


@json_cache
def _system_one(model: str, state: str, questions: str) -> dict:
    response = client.system_one(
        state=json.loads(state), questions=json.loads(questions), model=model
    )
    return response.model_dump(mode="json")


def ask(state: dict, questions: dict) -> SystemOneResponse:
    """client.system_one, with the model pinned and the call cached."""
    as_json = {qid: q.model_dump(mode="json", exclude_none=True) for qid, q in questions.items()}
    raw = _system_one(TYPESAFE_MODEL, json.dumps(state), json.dumps(as_json))
    return SystemOneResponse.model_validate(raw)


def later_state(customer_id: str, message_index: int) -> dict:
    """One of the later messages, sent by this customer, with a fixed ticket ID."""
    n = 201 + 3 * list(CUSTOMERS).index(customer_id) + message_index
    message = DATA["later_messages"][message_index]
    return ticket_state(customer_id, f"T-{n}", DATA["later_received_on"], message["subject"],
                        message["text"])


slow = later_state("C-1042", 0)
team = ask(slow, ROUTE).answers["team"]
print(f"C-1042: {slow['ticket']['messages'][0]['text']!r}")
print(f"  plain Jev -> {team.choice} {team.probabilities[team.choice]:.2f}")

ask() es simplemente client.system_one con el modelo fijado y la caché @json_cache; later_state() asigna números de ticket fijos a los mensajes posteriores (desde T-201).

Deberías ver (publicación oficial):

text
C-1042: 'Dashboards have been really slow since this morning.'
  plain Jev -> cloud_ops 0.55

Visto por separado, este ticket suena a problema de la versión en la nube: Jev lo envía al equipo de nube con probabilidad 0.55. Que C-1042 está autoalojado en Windows Server no se menciona ni una palabra en el ticket.

Paso 3: escribe la compuerta de memoria, un Noul que decide «¿vale la pena recordarlo?» ​

Por qué: «qué recordar» debe ser una pregunta explícita, no un puñado de if-else dispersos por el código. Primero mira qué pinta tiene lo que se va a guardar: as_memory() empareja el state original con la respuesta de Jev:

python
def answer_text(question, answer):
    """The readable part of an answer: the chosen option's description, or the number."""
    if answer.type == "choice":
        return question.criteria[answer.choice]
    return answer.noul if answer.type == "noul" else answer.score


def as_memory(state: dict, questions: dict, response: SystemOneResponse) -> dict:
    return {
        "request": state,
        "jev_answered": {
            q.instructions: answer_text(q, response.answers[qid])
            for qid, q in questions.items()
        },
    }


def remember_probability(memory: dict) -> float:
    """P(the request states an important fact about the customer), with the answer as context."""
    return ask(memory, GATE).answers["remember"].noul

Los dos nombres de clave tienen su porqué: request guarda el state original antes de añadir la memoria: la memoria antigua nunca se anida dentro de la nueva; jev_answered mapea cada pregunta al texto de su respuesta (las respuestas de Choice guardan la descripción de la opción elegida).

La compuerta en sí es un Noul (texto GATE oficial tal cual). Fíjate en las dos restricciones de las instructions: solo cuenta lo que el cliente o el personal de soporte escribieron en request.ticket; jev_answered es solo contexto, lo que diga o sugiera no cuenta:

python
GATE = {
    "remember": Noul(
        instructions=(
            "In `request.ticket`, does the thread state a lasting fact about the customer that "
            "should change how their future, unrelated tickets are handled? Count what the "
            "customer or our support staff wrote in `request.ticket`. `jev_answered` shows how "
            "the ticket was routed, which may rely on things learned earlier: do not count "
            "anything it says or implies."
        ),
        criteria=NoulCriteria(
            true=(
                "Yes: in `request.ticket` the customer or our support staff state something "
                "about the customer that stays true after this ticket, such as the product "
                "edition or operating system they run, their plan or contract, or a standing "
                "preference."
            ),
            false=(
                "No: `request.ticket` only contains things specific to this one ticket or "
                "moment, such as a one-off request, today's schedule, or the device they "
                "happen to be typing on; or the lasting fact appears only in `jev_answered`."
            ),
        ),
    ),
}

¿Por qué las respuestas no cuentan? La documentación oficial da dos razones: primero, las respuestas genéricas, como «General product questions: features, how-to, settings», que le encaja a cualquiera, aplastan los hechos reales del cliente en la petición; segundo, las respuestas derivadas de memoria antigua se volverían a guardar como hechos nuevos, y la memoria se reproduce a sí misma.

💡 Prueba primero los tickets en chino antes de pasar a producción

Nota oficial: el inglés es el idioma principal de entrenamiento de Jev; otros idiomas, incluido el chino, funcionan pero con menor precisión. Antes de cambiar GATE y ROUTE al chino, o de aplicar la compuerta a tickets en chino, ejecuta primero un lote con tus propios tickets y mira si las probabilidades de los grupos «debe recordar / no debe recordar» se separan bien, y solo entonces define REMEMBER_AT.

Noul no tiene un confidence separado——para unificar el umbral con otros tipos de pregunta, puedes calcular tú mismo |2p − 1| según la fórmula oficial (ver Confidence 置信度).

Deberías ver: este paso no produce salida——remember_probability() no se invoca realmente hasta la siguiente sección.

Paso 4: envolver todo en un ask_with_memory()——el núcleo del sistema de memoria de IA ​

Por qué: tres funciones pequeñas cosen la compuerta y el state——este es el sistema de memoria de IA completo; el código oficial tiene en total 18 líneas:

python
MEMORIES: dict[str, list[dict]] = {}  # customer ID -> that customer's saved memories


def customer_id(state: dict) -> str:
    return state["customer"]["id"]


def ask_with_memory(state: dict, questions: dict) -> SystemOneResponse:
    """ask(), plus memory: same arguments, same return value."""
    # 1. Answer the call with this customer's existing memories.
    saved = MEMORIES.get(customer_id(state), [])
    response = ask({**state, MEMORY_KEY: saved} if saved else state, questions)

    # 2. Ask Jev whether the original request states an important fact worth keeping.
    memory = as_memory(state, questions, response)
    if remember_probability(memory) >= REMEMBER_AT:
        MEMORIES.setdefault(customer_id(state), []).append(memory)
    return response

Lee tres veces estas 18 líneas: ① si hay memoria, envía {**state, MEMORY_KEY: saved}; si no, envía tal cual; ② solo hace append si pasa la compuerta y P ≥ 0.5; ③ el valor de retorno es idéntico al de ask()——quien llama no necesita saber si se guardó memoria o no.

La documentación oficial señala cinco consecuencias de este diseño, y cada una vale la pena recordar:

#ConsecuenciaDetalle
1Dos peticiones en serie por cada llamadaprimero enruta y luego la compuerta——la compuerta necesita ver la respuesta, así que solo puede correr después de la petición de enrutamiento; si tu compuerta no mira la respuesta, puedes integrarla en la petición de enrutamiento como segunda pregunta (preguntas en paralelo y fan-out especulativo)
2La memoria solo crece, nunca se reducecada memoria entra en todas las llamadas posteriores de ese cliente; no hay límite de tamaño, ni verificación de relevancia, ni expiración
3Las preguntas nunca mencionan la memoriala memoria entra en la clave earlier_tickets_from_this_customer del state, y Jev lee el state completo——ROUTE no hay que cambiarle ni una palabra
4El state debe tener customer.idel Jev desnudo también acepta un state como string, pero la función envolvente necesita el ID para encontrar la lista de ese cliente
5Las respuestas guardadas repiten erroresla compuerta no cuenta respuestas, y una respuesta por sí sola no puede hacer que un ticket se guarde; pero los tickets guardados llevan consigo la respuesta, que se lee en cada llamada posterior——una inferencia errónea se arrastra para siempre

💡 Este es el valor único de Jev

«Qué recordar» no son instrucciones dispersas en el prompt, ni tampoco el compromiso de guardarlo todo——es un Noul con probabilidad calibrada: en la grabación oficial, las tres 0.96–0.98 que debían recordarse y las que no debían guardarse quedaron todas ≤ 0.04, con los dos grupos bien separados; por eso REMEMBER_AT = 0.5 se atreve a trazar la línea en medio. Cambiar «qué recordar» = cambiar la redacción de GATE; cambiar «qué tan seguro debe estar para recordar» = cambiar una constante——sin tocar la cadena de llamadas.

Deberías ver: este paso tampoco produce salida nueva——la siguiente sección lo pone en marcha.

Paso 5: enviar cinco tickets tempranos y ver cómo cada memoria reescribe las respuestas ​

Por qué: el experimento de sondeo oficial——antes y después de cada ticket temprano se envían dos mensajes de seguimiento (panel lento, añadir 20 puestos) para ver el impacto inmediato de cada memoria. Los mensajes repetidos también pasan por la compuerta, así que esta también emite un veredicto sobre ellos:

python
PROBES = {"Slow dashboards": 0, "More seats": 2}  # later messages to send after each ticket


def memory_ids(cid: str) -> str:
    return ", ".join(m["request"]["ticket"]["id"] for m in MEMORIES.get(cid, [])) or "none"


def send_probes(cid: str) -> None:
    for subject, i in PROBES.items():
        team = ask_with_memory(later_state(cid, i), ROUTE).answers["team"]
        print(f"      {subject:<16} -> {team.choice:<19} {team.probabilities[team.choice]:.2f}")


for cid in CUSTOMERS:
    print(f"{cid}, memories: {memory_ids(cid)}")
    send_probes(cid)

for state in EARLIER:
    cid = customer_id(state)
    response = ask_with_memory(state, ROUTE)
    p = remember_probability(as_memory(state, ROUTE, response))  # cached: the wrapper's call
    verdict = "saved" if p >= REMEMBER_AT else "not saved"
    text = state["ticket"]["messages"][0]["text"]
    print(f"\n{cid} {state['ticket']['id']}  {response.answers['team'].choice:<19} "
          f"P(remember) {p:.2f}  {verdict}")
    print(f"    {text[:84]}")
    print(f"{cid}, memories: {memory_ids(cid)}")
    send_probes(cid)

Esa línea de comentario # cached: the wrapper's call merece atención: la función envolvente ya preguntó una vez a la compuerta, así que aquí la segunda consulta acierta la caché y no gasta una petición nueva.

Deberías ver (publicación oficial, tabla de sondeo completa):

text
C-1042, memories: none
      Slow dashboards  -> cloud_ops           0.55
      More seats       -> enterprise_desk     0.53
C-2210, memories: none
      Slow dashboards  -> cloud_ops           0.68
      More seats       -> billing             0.58

C-1042 T-101  selfhosted_windows  P(remember) 0.97  saved
    Hi, we run your self-hosted edition on Windows Server 2022 in our own data centre. H
C-1042, memories: T-101
      Slow dashboards  -> selfhosted_windows  0.99
      More seats       -> enterprise_desk     0.53

C-2210 T-102  general             P(remember) 0.98  saved
    We're a small design studio on your cloud edition, paying monthly on the self-serve
C-2210, memories: T-102
      Slow dashboards  -> cloud_ops           0.98
      More seats       -> billing             0.98

C-1042 T-103  billing             P(remember) 0.02  not saved
    Sorry for the typos, typing this on my phone at the airport. Where can I download la
C-1042, memories: T-101
      Slow dashboards  -> selfhosted_windows  0.99
      More seats       -> enterprise_desk     0.53

C-2210 T-104  general             P(remember) 0.03  not saved
    Our whole team is out on Friday for a public holiday, so no rush on this one. Is the
C-2210, memories: T-102
      Slow dashboards  -> cloud_ops           0.98
      More seats       -> billing             0.98

C-1042 T-105  enterprise_desk     P(remember) 0.96  saved
    For context, we signed an Enterprise contract with you in March. Can we get a sandbo
C-1042, memories: T-101, T-105
      Slow dashboards  -> selfhosted_windows  0.98
      More seats       -> enterprise_desk     1.00

Lee esta tabla (la interpretación oficial coincide punto por punto):

  • Las tres que debían guardarse se guardan con 0.96–0.98: T-101 versión 0.97, T-102 plan 0.98, T-105 contrato 0.96
  • T-102 se enruta al equipo general y aun así se guarda——la compuerta cuenta lo que escribió el cliente, no la respuesta de enrutamiento; por eso el veredicto de «añadir 20 puestos» salta de billing 0.58 a 0.98
  • El aeropuerto 0.02 y el día festivo 0.03 no se guardan——ninguna de sus respuestas de sondeo posteriores cambió
  • Cada memoria solo cambia las respuestas relacionadas con ella: el ticket de Windows de C-1042 mueve el panel lento del equipo de nube 0.55 al equipo de Windows 0.99, y el contrato Enterprise eleva el enterprise_desk de añadir puestos de 0.53 a 1.00; el plan Team de C-2210 eleva el equipo de nube 0.68 a 0.98 y billing 0.58 a 0.98
  • La compuerta no guardó ninguno de los mensajes repetidos——el mismo ticket de sondeo enviado dos veces, el veredicto de la compuerta no cambia

Deberías ver: tu salida coincide línea por línea con la tabla anterior (idéntica en la repetición de caché; en ejecución live las probabilidades variarán, y la tendencia se rige por la versión que hayas fijado).

  • Esta tabla se puede reproducir; puedo explicar por qué T-102 se enruta a general y aun así se guarda

Paso 6: conciliación——el mismo mensaje, enrutado una vez con Jev desnudo y otra con memoria ​

Por qué: la conciliación final. A cada cliente se le envían los tres mensajes de seguimiento, con el mismo state y las mismas preguntas, pasando respectivamente por ask() y ask_with_memory(). Los equipos esperados no son a ojo——el comentario en DATA lo deja claro: fueron anotados a mano según lo que cada cliente dijo en sus tickets tempranos (versión self-hosted + contrato Enterprise de C-1042, plan Team en nube de C-2210):

python
EXPECTED = DATA["expected_team"]
plain_correct = memory_correct = total = 0
example_state = None


def cell(answer, expected: str) -> str:
    mark = "✓" if answer.choice == expected else "✗"
    return f"{mark} {answer.choice} {answer.probabilities[answer.choice]:.2f}"


print(f"{'customer':<9}{'message':<17}{'expected':<20}{'plain Jev':<27}{'with memory':<27}")
for cid in CUSTOMERS:
    for i, message in enumerate(DATA["later_messages"]):
        state = later_state(cid, i)
        expected = EXPECTED[cid][message["subject"]]
        plain = ask(state, ROUTE).answers["team"]
        if example_state is None:
            # Keep the exact state used for this call for the playground link.
            saved = MEMORIES.get(cid, [])
            example_state = json.loads(json.dumps({**state, MEMORY_KEY: saved} if saved else state))
        response = ask_with_memory(state, ROUTE)
        remembered = response.answers["team"]
        plain_correct += plain.choice == expected
        memory_correct += remembered.choice == expected
        total += 1
        print(f"{cid:<9}{message['subject']:<17}{expected:<20}{cell(plain, expected):<27}"
              f"{cell(remembered, expected):<27}")

print(f"\nExpected routes: {plain_correct}/{total} without memory, "
      f"{memory_correct}/{total} with memory.")

example_state Esas líneas están reservadas para el enlace final del Playground——capturan el state exacto de la primera llamada de panel lento de C-1042 en su momento (incluidas las memorias ya guardadas entonces).

Deberías ver (publicación oficial):

text
customer message          expected            plain Jev                  with memory
C-1042   Slow dashboards  selfhosted_windows  ✗ cloud_ops 0.55           ✓ selfhosted_windows 0.98
C-1042   Upgrade failing  selfhosted_windows  ✗ none_suitable 0.64       ✓ selfhosted_windows 1.00
C-1042   More seats       enterprise_desk     ✓ enterprise_desk 0.53     ✓ enterprise_desk 1.00
C-2210   Slow dashboards  cloud_ops           ✓ cloud_ops 0.68           ✓ cloud_ops 0.98
C-2210   Upgrade failing  cloud_ops           ✗ none_suitable 0.58       ✓ cloud_ops 0.95
C-2210   More seats       billing             ✓ billing 0.58             ✓ billing 0.98

Expected routes: 3/6 without memory, 6/6 with memory.

3/6 contra 6/6. Cuatro filas merecen atención:

  • La misma frase va a equipos distintos: panel lento, C-1042 va al equipo de Windows y C-2210 se queda en el equipo de nube; añadir puestos, C-1042 va a enterprise_desk y C-2210 a billing——la memoria hace que «cómo enrutar» siga al cliente, no solo a la frase
  • Los dos none_suitable se salvan por completo: los tickets de escalado fallido no mencionan el entorno y carecen de contexto, así que el Jev desnudo solo puede responder «ningún equipo es adecuado»; con memoria, ambos van respectivamente al equipo de Windows 1.00 y al equipo de nube 0.95
  • En las tres filas que el Jev desnudo ya acertaba, la memoria eleva la probabilidad: añadir puestos de C-1042 pasa de 0.53 a 1.00——la memoria no solo cambia el acierto, también la certeza
  • la compuerta no guardó ni uno de estos seis mensajes posteriores—no enuncian hechos duraderos, la memoria no tiene adiciones

📋 Prompt mágico ​

El «Prompt» de esta página es una plantilla de pregunta y envoltura para la API—cópiala, sustituye los marcadores 【】 (los que llevan ? son opcionales) y ya se puede usar.

📝 Compuerta de memoria (versión Noul) ​

Efecto esperado: escribir «qué recordar» como una pregunta explícita de sí/no, obtener una probabilidad 0–1, y que el umbral en el código decida si se guarda o no.

python
GATE = {
    "remember": Noul(
        instructions=(
            "【在 `request.ticket` 里,这个线程是否陈述了关于客户的一条持久事实——"
            "它应该改变客户未来、与这张工单无关的工单的处理方式?只数客户或支持人员"
            "在 `request.ticket` 里写下的话。`jev_answered` 显示这张工单被如何路由,"
            "可能依赖早先学到的东西:它说的或暗示的任何内容都不要数。】"
        ),
        criteria=NoulCriteria(
            true="【是:客户或支持人员在 `request.ticket` 里陈述了这张工单之后仍然为真的东西——如产品版本、操作系统、套餐、合同、长期偏好】",
            false="【否:`request.ticket` 只有属于这张工单或这一刻的内容——如一次性请求、当天日程、碰巧在用的设备;或持久事实只出现在 `jev_answered` 里】",
        ),
    ),
}
# 必填项:state = as_memory() 配好的 {"request": 加记忆前的原始 state, "jev_answered": {问题 instructions: 答案文本}}
# 选填项:true/false 里的例子换成你领域「值得记 / 不值得记」的清单?
# 输出规范:response.answers["remember"].noul → 0–1 概率(Noul 无单独 confidence)
# 约束条件:
# ✅ 一道 Noul 只问「该不该记」;记多久、给谁看,是代码的事
# ✅ 官方英文原文最稳(见第 3 步);中文化先用你自己的数据验证再上线
# ❌ 不要数 `jev_answered`——通用答案会压过真事实,靠旧记忆得出的答案会被当新事实再存

✅ Envoltura de memoria y umbral (versión ask_with_memory) ​

Efecto esperado: antes de la llamada incluye la memoria automáticamente, después de la llamada pasa por la compuerta automáticamente; mismos parámetros y mismo valor de retorno que ask(), el código existente se cambia sin ninguna modificación.

python
REMEMBER_AT = 【0.5】  # 多确定才记:官方给这道闸门的起点阈值
MEMORY_KEY = "【earlier_tickets_from_this_customer】"  # 记忆放进 state 用的键名
MEMORIES: dict[str, list[dict]] = {}  # 客户 ID -> 该客户的记忆列表


def ask_with_memory(state: dict, questions: dict) -> SystemOneResponse:
    """ask(), plus memory: same arguments, same return value."""
    saved = MEMORIES.get(customer_id(state), [])
    response = ask({**state, MEMORY_KEY: saved} if saved else state, questions)
    memory = as_memory(state, questions, response)
    if remember_probability(memory) >= REMEMBER_AT:
        MEMORIES.setdefault(customer_id(state), []).append(memory)
    return response
# 必填项:state 里必须有 customer.id——包装函数靠它找该客户的记忆列表
# 选填项:记忆长了加一道相关性问题,只挑子集并进 state?
# 输出规范:返回值与 ask() 完全相同——存没存记忆,调用方都不用管
# 约束条件:
# ✅ 先路由后闸门——闸门要看答案,只能在路由请求之后跑
# ✅ as_memory() 的 request 键存加记忆前的原始 state——旧记忆不会嵌套进新记忆
# ❌ 别把 MEMORIES 直接上线——内存字典进程退出就没了,官方 Next steps:换按客户 ID 键的数据库

🔧 Tu propia pregunta de enrutamiento (versión Choice) ​

Efecto esperado: una sola Choice asigna los tickets a un conjunto fijo de equipos;none_suitable da un destino a los tickets con contexto insuficiente.

python
ROUTE = {
    "team": Choice(
        instructions="【这张工单该哪个支持团队接?判断 `ticket`】",
        criteria={
            "【选项 ID】": "【选项描述:什么情况归这个团队】",
            "none_suitable": "【以上团队都不适合这张工单】",
        },
    ),
}
# 必填项:选项 map——ID 是代码读的,描述是 Jev 读的
# 选填项:官方 7 选项全集见第 2 步(cloud_ops / selfhosted_linux / selfhosted_windows / billing / enterprise_desk / general / none_suitable)?
# 输出规范:answers["team"].choice + probabilities(每个选项)+ confidence
# 约束条件:
# ✅ 列表可能不全时留 none_suitable(或 other)——上下文不足的工单有地方去
# ✅ 记忆进 state 后,这道题一个字不用改——Jev 读整个 state
# ❌ 不要在 instructions 里提「记忆」——记忆是 state 的事,不是问题的事

Punto de control ✅ ​

  • Puedo nombrar los dos componentes de este sistema de memoria de IA: tras la llamada, una compuerta Noul decide si vale la pena recordar (solo se guarda si P ≥ 0.5); antes de la llamada, los tickets ya guardados de ese cliente se incorporan con sus respuestas al state
  • Sé por qué la compuerta solo cuenta lo escrito en request.ticket: las respuestas genéricas aplastarían los hechos reales, y las respuestas derivadas de memoria antigua se volverían a guardar como hechos nuevos
  • De los cinco tickets iniciales, tres se guardan y dos no: versión / plan / contrato 0.96–0.98 se guardan; teléfono en aeropuerto 0.02, festivo público 0.03 no—T-102 enrutado a general igualmente se guarda
  • Experimento de conciliación 3/6 → 6/6: la misma frase «el dashboard va lento», C-1042 va al equipo de Windows, C-2210 se queda en el equipo de nube; el Jev desnudo acertaba tres líneas, la memoria elevó la probabilidad de 0.53 a 1.00
  • De las cinco consecuencias puedo nombrar tres: dos peticiones en serie por llamada, memoria que solo crece, el state necesita customer.id (las otras dos: la pregunta nunca menciona la memoria, las respuestas guardadas repiten errores)

Advertencias de tropiezos ​

❌ La compuerta cuenta también la respuesta de Jev ​

Contar jev_answered también en el juicio de «vale la pena recordar» provoca dos cosas que la documentación oficial menciona por su nombre: las respuestas genéricas («General product questions: features, how-to, settings») aplastarían los hechos reales del cliente en la petición—T-102 podría entonces no guardarse; y las respuestas derivadas de memoria antigua se guardarían como hechos nuevos una vez más, la memoria se autorreproduce.

La solución oficial está fijada en las instructions de GATE: contar solo lo que el cliente / el personal de soporte escriben en request.ticket; jev_answered es solo contexto, nada de lo que dice o insinúa cuenta.

❌ Para ahorrar una petición, fusionar sin más la compuerta en la petición de enrutamiento ​

La compuerta necesita ver «el ticket + la respuesta de Jev», y la respuesta solo existe después de la petición de enrutamiento—por eso, de las cinco consecuencias del paso 4, la primera es «dos peticiones en serie por llamada». La excepción oficial está explícita: si tu compuerta no mira la respuesta, puede convertirse en una segunda pregunta dentro de la petición de enrutamiento (fan-out especulativo, ver preguntas en paralelo y fan-out especulativo).

Piensa primero si tu compuerta necesita ver la respuesta, y luego decide si fusionarla.

❌ Cambiarse a la función envolvente sin customer.id en el state ​

El Jev desnudo acepta state como cadena, con cualquier forma;ask_with_memory() en cambio necesita state["customer"]["id"] para encontrar la lista de memorias de ese cliente. Antes de cambiar a la función envolvente, confirma que tu state lleva el ID del cliente.

❌ Poner en producción directamente la memoria de demostración «que solo crece» ​

Los tres «no hay» oficiales están escritos sin rodeos: no hay límite de tamaño, no hay verificación de relevancia, no hay caducidad. Cada memoria entra en todas las llamadas posteriores de ese cliente—y «un state gigante lleno de detalles irrelevantes» es justamente el modo de fallo conocido del manual de tropiezos Jev 1.13.

Hay dos riesgos más que la documentación oficial menciona por su nombre: los tickets guardados llevan sus respuestas consigo, así que las inferencias erróneas se arrastran para siempre;MEMORIES es un diccionario en memoria, al salir el proceso desaparece. La solución de los Next steps oficiales está en las técnicas avanzadas.

Técnicas avanzadas (opcional) ​

Calibrar REMEMBER_AT: el método oficial de calibración. El primer punto de los Next steps oficiales es este: de tu tráfico, marca un lote de pares «petición + respuesta», clasifícalos a mano en dos montones «vale la pena recordar / no vale la pena recordar», elige como umbral la probabilidad que mejor separa los montones, y verifica con el lote que no participó en la selección. Si una memoria engañosa cuesta caro, súbelo.

¿Por qué el punto de partida oficial es 0.5, más laxo que el «yes ≥ 0.7» del punto de partida genérico de Noul? El comentario del código solo dice que es un starting threshold (umbral de partida); el principio de Confidence es que el umbral escala con el riesgo—guardar una memoria es una acción reversible de bajo riesgo, 0.5 basta, y se sube si el coste es asimétrico. La documentación oficial también da una referencia: patrón confidence-based routing.

Cuando la memoria crece, la ruta de mejora oficial en cuatro pasos. Los Next steps restantes son cuatro, según necesidad: ① añadir una pregunta de relevancia que seleccione un subconjunto de la memoria larga para incorporarlo al state; ② preguntar si la memoria nueva sustituye a la antigua, y borrar en el código las entradas sustituidas; ③ cambiar MEMORIES por una base de datos indexada por ID de cliente; ④ añadir también las respuestas de tu aplicación al hilo del ticket como mensajes de soporte, y que la compuerta las juzgue junto con todo.

Reproducción sin key y cuenta de costes. Todas las llamadas están grabadas en el json_cache.json publicado oficialmente: tras deduplicar, 31 llamadas (las peticiones de sondeo repetidas aciertan en la misma entrada de caché, esa es la razón de que el número de entradas sea menor que el de llamadas lógicas)—19 de enrutamiento, 12 de compuerta; en total 21,456 tokens de entrada, 1,752 tokens de salida. Con la tarifa de $42/Btok de entrada y salida gratis, toda la página cuesta unos $0.0009.

Para experimentar solo una vez una llamada de enrutamiento con memoria: al pie de la página del cookbook oficial hay un enlace de Playground ya preparado—carga el state del momento de la primera llamada del dashboard lento de C-1042 (incluidas las dos memorias T-101 y T-105 ya guardadas entonces) + la pregunta de enrutamiento; al abrirlo puedes modificarlo en el navegador:

Abrir en el playground de TypeSafe el ticket de C-1042 y sus memorias →

Lo genera la última celda oficial: make_playground_link(example_state, ROUTE)—exactamente ese state capturado en el paso 6.

Conectarlo a tu aplicación. GATE y ROUTE ya son tuyos, la función envolvente se copia tal cual. Si usas Claude Code, instala el Agent Skill de TypeSafe y entrégale esta página:

bash
claude plugin marketplace add typesafe-ai/skills
claude plugin install typesafe@typesafe-ai

La recomendación oficial es concentrar la pregunta y la constante de umbral en un solo archivo, para facilitar la revisión humana—la redacción de GATE y REMEMBER_AT son tus dos «políticas»; todo cambio debería pasar por revisión de código.

Resumen de la lección ​

✅ Un sistema de memoria de IA = dos componentes: tras la llamada, una compuerta Noul (solo se guarda si P ≥ 0.5); antes de la llamada, los tickets ya guardados de ese cliente se incorporan con sus respuestas al state—ask_with_memory() y ask() con los mismos parámetros y el mismo valor de retorno, se cambia sin tocar el resto del código.

✅ «Qué recordar» es una pregunta explícita: GATE solo cuenta lo que el cliente / el personal de soporte escriben en la petición; lo que vale la pena recordar 0.96–0.98, lo que no ≤ 0.04—los dos grupos quedan lejos entre sí, por eso se atreve a trazar la línea en 0.5.

✅ Prueba oficial: con Jev desnudo, de las incidencias posteriores 3/6 correctas; con memoria 6/6 todas llegaron al equipo esperado. La incidencia del panel lento: 0.55 equipo cloud → 0.98 equipo Windows; al añadir asientos 0.53 → 1.00; las dos none_suitable fueron rescatadas.

✅ Límites claros: cada llamada hace dos peticiones en serie; la memoria solo crece, nunca se reduce; la pregunta nunca menciona la memoria; el state necesita customer.id; las respuestas guardadas repetirán errores.

Repaso de los campos de configuración clave:

CampoValor en esta páginaDescripción
REMEMBER_AT0.5Umbral de partida para guardar memoria; comentario oficial textual: starting threshold
MEMORY_KEYearlier_tickets_from_this_customerNombre de la clave de la memoria en el state; Jev lee el state completo, la pregunta no necesita cambiar
TYPESAFE_MODELjev-1.14.0Versión con los números grabados oficialmente; en una ejecución live, bloquea tu propio ID de versión
MEMORIESdict[str, list[dict]]diccionario en memoria indexado por ID de cliente, se pierde al salir del proceso; para producción, cámbialo por una base de datos
Tipo de pregunta de la compuertaNoul (sin confidence separado)El umbral se fija directamente sobre P(yes); para usar la misma escala que otros tipos de pregunta, calcula tú mismo «el valor absoluto de 2p − 1»
Forma del statecustomer (incluye id) + ticketLa función de envoltura usa customer.id para encontrar la lista de memorias

Tutoriales relacionados:

Avance de la próxima lección ​

La línea B (aplicaciones de LLM y Agent) termina aquí. La próxima lección comienza la línea C (documentos y datos): Extracción de valores: fechas, correos, teléfonos, importes.

Aprenderás:

  • Fechas: preguntar por partes al documento (absoluta o relativa), el código parsea y valida, confidence revisa
  • Correos, teléfonos, importes: la regex extrae primero los candidatos, Jev elige el correcto, el código luego normaliza
  • El mismo hábito que esta página: el acierto de la extracción no depende de la buena voluntad del modelo, sino de preguntas tipadas + validación en código
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.