Documentación

Sistema de memoria simple

Deja que Jev decida qué solicitudes y respuestas merece la pena recordar y luego envuelve la llamada a Jev en una pequeña función que añade memorias a las llamadas posteriores.

Cada solicitud a Jev solo ve el estado que le envías. Lo que un cliente le contó a tu aplicación el mes pasado, como su edición o su plan, no está en su siguiente solicitud a menos que tu código lo ponga ahí. El sistema de memoria que hay aquí lo consigue con una solicitud extra a Jev por llamada y un diccionario de Python.

Nuestro ejemplo enruta tickets de soporte. En agosto, un cliente dijo que se autoaloja en Windows Server. En septiembre escribe “Dashboards have been really slow since this morning”. Sin memoria, Jev envía ese ticket al equipo de la nube en lugar del equipo autohospedado. En el ejemplo de abajo, añadir memoria envía los seis tickets posteriores a los equipos esperados. Enrutar cada ticket por separado acierta dos de seis.

El sistema de memoria simple tiene dos partes:

  • Después de cada llamada, Jev ve juntas la solicitud original y su respuesta. Una pregunta Noul, a la que llamamos la puerta, pregunta si la solicitud enuncia un dato importante sobre el cliente que deba recordarse. Si P(sí) es al menos 0.5, el ticket y la respuesta de Jev se guardan como una memoria para ese cliente.
  • Una función envoltorio, ask_with_memory(), toma los mismos argumentos state y questions que ask(), que es el método client.system_one del SDK de Python de TypeSafe con el modelo fijado y la llamada cacheada, y devuelve la respuesta de Jev. Antes de cada llamada, añade al estado los tickets guardados del cliente y las respuestas de Jev a ellos.

Ese envoltorio es un harness de agente básico. Un harness es el código alrededor de un modelo que le da capacidades extra, como llamadas a herramientas y ejecución en bucles. Este harness básico de juguete solo le da memoria en un diccionario de Python normal, con una lista por ID de cliente.

  %%{init: {"fontFamily": "Inter, sans-serif", "flowchart": {"rankSpacing": 25, "wrappingWidth": 300, "subGraphTitleMargin": {"top": 8, "bottom": 20}}}}%%
flowchart TB
    IN["ask_with_memory(state, questions)"]
    subgraph R["Jev: answer the question"]
        Q1["<b>Choice:</b> which support team?"]
    end
    subgraph G["Jev: judge the routed ticket"]
        Q2["<b>Noul:</b> does the request state<br/>an important fact about the customer?"]
    end
    DEC{"P(yes) ≥ 0.5?<br/>your code"}
    SAVE["save the memory<br/>under this customer's ID"]
    OUT["handle the support ticket response in your code"]
    MEM[("MEMORIES<br/>saved memories per customer")]
    IN -- "state with memories<br/>+ routing question" --> R
    R -- "original request + answer<br/>+ memory question" --> G
    G -- "P(yes)" --> DEC
    DEC -- "yes: save" --> SAVE
    DEC -- "no: don't save" --> OUT
    SAVE --> OUT
    SAVE --> MEM
    IN -. "added to the state<br/>on this customer's<br/>next support tickets" .- MEM

El envoltorio hace dos solicitudes a Jev, una tras otra: la solicitud de enrutamiento y luego la puerta, que juzga el ticket junto con la respuesta de Jev. El envoltorio devuelve la respuesta de enrutamiento se guarde algo o no.

Como ask_with_memory() toma los mismos argumentos que ask() y devuelve la misma respuesta, puedes cambiar uno por otro sin tocar ningún otro código. El envoltorio busca las memorias del cliente, las añade al estado y guarda las nuevas por su cuenta.

El ejemplo pasa cinco tickets anteriores de dos clientes por el envoltorio y luego enruta tres mensajes posteriores de cada cliente dos veces: una con las memorias que guardó y otra sin ellas. Una tabla pone las dos respuestas una al lado de la otra para los seis.

Configuración

pip install ipython 'cooksafe>=0.2.0,<0.3.0'

Define TYPESAFE_API_KEY. Cada llamada a la API se cachea en json_cache.json. Descárgalo a la carpeta desde la que ejecutas este código para reproducir las cifras publicadas en lugar de llamar a la API, o déjalo fuera para ejecutarlo todo en vivo.

Las cifras de abajo vienen de jev-1.13.0 el 2026-09-28. El umbral de memoria de 0.5 es un punto de partida. Deberías evaluarlo con tus propios ejemplos.

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.13.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"))

Define los tickets

Dos clientes, cinco tickets anteriores y tres mensajes posteriores, todos escritos para este cookbook. C-1042 (Harbor Logistics) usa la edición autohospedada en Windows Server bajo un contrato Enterprise. C-2210 (Fernwood Studio) está en el plan Team autoservicio de la edición en la nube. Tres de los tickets anteriores enuncian un dato duradero: una edición, un plan, un contrato. Dos no: un teléfono en el aeropuerto, un día festivo. Ningún mensaje posterior menciona la configuración del cliente, así que sin memoria Jev tiene que adivinarla.

Cada ticket se convierte en un estado con dos partes: customer, quién es el cliente, y ticket, el hilo del ticket. La función ticket_state() construye un ticket simplificado, como uno de un helpdesk. En tu aplicación, el estado es cada ticket tal como lo envía tu helpdesk, y ask_with_memory() le añade los tickets guardados del cliente. La división entre tickets anteriores y mensajes posteriores es solo para este ejemplo.

DATA = {
    "customers": {
        "C-1042": {"id": "C-1042", "company": "Harbor Logistics"},
        "C-2210": {"id": "C-2210", "company": "Fernwood 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))
2 customers, 5 earlier tickets, 3 later messages. The first ticket as Jev sees it:

{
  "customer": {
    "id": "C-1042",
    "company": "Harbor Logistics"
  },
  "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?"
      }
    ]
  }
}

Enruta un ticket

Una pregunta Choice elige el equipo de soporte. La opción none_suitable le da a Jev una respuesta para cuando no encaja ningún equipo, y un ticket con muy poco contexto puede acabar ahí.

El ayudante ask() es client.system_one con la versión del modelo fijada y cada llamada cacheada. Toma un estado y un diccionario de preguntas y devuelve el propio objeto de respuesta del SDK, así que el código que ya lee respuestas de client.system_one funciona con él sin cambios.

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}")
C-1042: 'Dashboards have been really slow since this morning.'
  plain Jev -> cloud_ops 0.80

Jev sin memoria envía las “slow dashboards” de C-1042 al equipo de la nube. Este ticket por sí solo no le da ninguna razón para hacer otra cosa.

Pregunta a Jev si merece la pena recordar el ticket

Primero, as_memory() empareja el estado original con la respuesta de Jev: la memoria que el envoltorio puede guardar. La clave request contiene el estado antes de que se inyectaran las memorias, y jev_answered asigna cada pregunta a su respuesta. Esto evita que las memorias antiguas se aniden dentro de cada memoria nueva.

Una segunda llamada a Jev lee ese par. La puerta pregunta si la solicitud enuncia un dato importante sobre el cliente, como su edición, su sistema operativo, su plan o su contrato. La respuesta de Jev está ahí como contexto, pero un dato que aparece solo en la respuesta no cuenta. Sin esa regla, una respuesta genérica como “General product questions” puede pesar más que un dato real en la solicitud, y una respuesta que se apoyó en una memoria anterior puede guardarse otra vez como si fuera nueva.

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`."
            ),
        ),
    ),
}

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

Envuelve la llamada para que recuerde

El envoltorio, ask_with_memory(), tiene los mismos argumentos y el mismo valor de retorno que ask(). El almacén de memorias es un diccionario normal con una lista por ID de cliente. El envoltorio usa el ID del estado para seleccionar las memorias del cliente.

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

Añadir memoria de esta forma tiene cuatro consecuencias para tu aplicación:

  • Cada llamada hace dos solicitudes secuenciales, tu llamada seguida de la puerta de memoria. La puerta juzga el ticket junto con la respuesta de Jev, así que se ejecuta después de la solicitud de enrutamiento. Si tu puerta ignorara la respuesta, podría en cambio ser una segunda pregunta en la solicitud de enrutamiento (consulta fan-out).
  • La memoria solo crece. Cada memoria guardada entra en cada llamada posterior de ese cliente. Aquí no hay límite de tamaño, ni comprobación de relevancia, ni fecha de caducidad. La sección de Próximos pasos tiene ideas para cada cosa.
  • Tus preguntas nunca mencionan las memorias. Las memorias entran en el estado bajo earlier_tickets_from_this_customer, y Jev lee todo el estado. Nada en ROUTE cambia.
  • El estado necesita customer.id. Jev sin memoria también acepta una cadena como estado, pero este envoltorio necesita el ID para encontrar la lista del cliente.

Envía los tickets anteriores y observa cómo cambian las respuestas

Envía los cinco tickets anteriores por ask_with_memory(), en el orden en que llegaron. El mismo cliente envía dos de los mensajes posteriores otra vez: slow dashboards y 20 seats más. Eso muestra cómo cada memoria guardada cambia las respuestas de Jev. Los mensajes repetidos pasan también por el envoltorio, así que la puerta los juzga a ellos también.

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)
C-1042, memories: none
      Slow dashboards  -> cloud_ops           0.80
      More seats       -> enterprise_desk     0.62
C-2210, memories: none
      Slow dashboards  -> cloud_ops           0.75
      More seats       -> enterprise_desk     0.52

C-1042 T-101  selfhosted_windows  P(remember) 0.91  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.44

C-2210 T-102  general             P(remember) 0.91  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.91
      More seats       -> billing             0.98

C-1042 T-103  billing             P(remember) 0.07  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.44

C-2210 T-104  general             P(remember) 0.10  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.91
      More seats       -> billing             0.98

C-1042 T-105  enterprise_desk     P(remember) 0.92  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.94
      More seats       -> enterprise_desk     0.99

Los tres tickets que enuncian una edición, un plan o un contrato se guardan con 0.91 a 0.92. T-102 se guarda aunque Jev lo enrutó al equipo general, porque la puerta cuenta las palabras del cliente, no la respuesta. Los tickets del aeropuerto y del día festivo puntúan 0.07 y 0.10 y no se guardan, así que las respuestas posteriores a ellos no cambian.

Cada memoria guardada cambia las respuestas con las que es relevante. Para C-1042, el ticket de Windows mueve slow dashboards del equipo de la nube (0.80) al equipo de Windows (0.99). El contrato Enterprise luego fija seats en 0.99. Para C-2210, el ticket del plan Team sube el equipo de la nube de 0.75 a 0.91 y mueve seats del escritorio Enterprise (0.52) a billing (0.98). Añadir la memoria Enterprise baja ligeramente las slow dashboards de C-1042, de 0.99 a 0.94, que es una razón para elegir qué memorias añadir (consulta Próximos pasos). La puerta no guardó ninguno de los mensajes repetidos.

Enruta los mismos mensajes para ambos clientes

Cada cliente envía ahora los tres mensajes posteriores. Cada mensaje va a ask() sin memoria y a ask_with_memory(), con el mismo estado y la misma pregunta.

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.")
customer message          expected            plain Jev                  with memory
C-1042   Slow dashboards  selfhosted_windows  ✗ cloud_ops 0.80           ✓ selfhosted_windows 0.94
C-1042   Upgrade failing  selfhosted_windows  ✗ none_suitable 0.60       ✓ selfhosted_windows 1.00
C-1042   More seats       enterprise_desk     ✓ enterprise_desk 0.62     ✓ enterprise_desk 0.99
C-2210   Slow dashboards  cloud_ops           ✓ cloud_ops 0.75           ✓ cloud_ops 0.91
C-2210   Upgrade failing  cloud_ops           ✗ none_suitable 0.63       ✓ cloud_ops 0.86
C-2210   More seats       billing             ✗ enterprise_desk 0.52     ✓ billing 0.98

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

Con memoria, los seis mensajes llegan al equipo esperado, frente a dos sin ella. El mismo mensaje ahora va a un equipo distinto para cada cliente: slow dashboards van al equipo de Windows para C-1042 y se quedan con el equipo de la nube para C-2210, y 20 seats más van al escritorio Enterprise para C-1042 y a billing para C-2210. Donde Jev sin memoria ya acertaba, la memoria sube la probabilidad, de 0.62 a 0.99 para los seats de C-1042. El envoltorio también juzgó los seis mensajes posteriores y no guardó ninguno: no enuncian ningún dato importante.

El equipo esperado de cada fila se deduce de la configuración del cliente en los tickets anteriores: la edición autohospedada y el contrato Enterprise de C-1042, el plan Team en la nube de C-2210.

Ábrelo en el playground

El enlace contiene el estado de enrutamiento exacto usado para la primera llamada de slow dashboards de C-1042, incluidas sus memorias en ese momento, más la pregunta de enrutamiento.

playground_link = make_playground_link(example_state, ROUTE, models=[TYPESAFE_MODEL])
display(Markdown(
    f"🔗 [Open C-1042's ticket with its memories in the TypeSafe playground]({playground_link})"
))
Abre el ticket de C-1042 con sus memorias en el playground de TypeSafe →

Próximos pasos

  • Elige qué debe recordar tu aplicación. Edita GATE para describir qué merece la pena recordar en tu propia tarea, y prueba REMEMBER_AT con ejemplos que hayas etiquetado.
  • Elige qué memorias añadir. El envoltorio añade todas las memorias guardadas. Una pregunta de relevancia puede seleccionar un conjunto más pequeño cuando la lista se haga larga.
  • Sustituye las memorias obsoletas. Pregunta si una memoria nueva sustituye a una antigua, y luego elimina la entrada vieja en el código cuando corresponda.
  • Conserva las memorias entre ejecuciones. Sustituye MEMORIES por una base de datos indexada por ID de cliente. El diccionario en memoria desaparece cuando el proceso termina.
  • Actúa sobre la ruta. Asigna cada equipo a un manejador en el código, como reservar una llamada para clientes Enterprise o enviar un artículo específico de la configuración. Consulta intent routing y confidence-based routing. Añade tu respuesta al hilo del ticket como un mensaje de soporte, y la puerta podrá recordar lo que hiciste.

Apéndice

¿Puede una respuesta guardada reforzar un error?

Sí. La puerta ignora cualquier cosa que aparezca solo en la respuesta de Jev, así que una respuesta no puede hacer que un ticket se guarde por sí sola. Una vez que un ticket se guarda, sin embargo, su respuesta se guarda con él, con la inferencia errónea y todo, y cada llamada posterior de ese cliente la lee. Una respuesta posterior puede entonces repetir el error.

¿Cómo debería elegir el umbral?

El 0.5 de este envoltorio es un valor de partida. Para elegir el tuyo, etiqueta pares de solicitud y respuesta de tu tráfico como que merecen la pena recordarse o no, y encuentra la probabilidad que mejor separe los dos grupos. Compruébala con pares que no usaste para elegirla. Súbela si una memoria engañosa cuesta más que una que falta; bájala si es al contrario. Consulta Confidence y Confidence-Gated Routing para elegir umbrales y ajustarlos al riesgo de cada acción.