Documentation

Système de mémoire simple

Laisse Jev décider quelles requêtes et quelles réponses valent la peine d’être mémorisées, puis enveloppe l’appel à Jev dans une petite fonction qui ajoute ces souvenirs aux appels suivants.

Chaque requête Jev ne voit que l’état que tu lui envoies. Ce qu’un client a dit à ton application le mois dernier, comme son édition ou son forfait, ne figure pas dans sa requête suivante à moins que ton code ne l’y mette. Le système de mémoire présenté ici le fait avec une requête Jev supplémentaire par appel et un dictionnaire Python.

Notre exemple aiguille des tickets de support. En août, un client a indiqué qu’il héberge lui-même sur Windows Server. En septembre, il écrit « Dashboards have been really slow since this morning ». Sans mémoire, Jev envoie ce ticket à l’équipe cloud plutôt qu’à l’équipe auto-hébergée. Dans l’exemple ci-dessous, l’ajout de mémoire envoie les six tickets ultérieurs vers les équipes attendues. Aiguiller chaque ticket isolément n’en réussit que deux sur six.

Le système de mémoire simple comporte deux parties :

  • Après chaque appel, Jev voit la requête d’origine et sa réponse ensemble. Une question Noul, que nous appelons la porte, demande si la requête énonce un fait important sur le client qui mérite d’être mémorisé. Si P(oui) est au moins 0,5, le ticket et la réponse de Jev sont enregistrés comme souvenir pour ce client.
  • Une fonction d’enveloppe, ask_with_memory(), prend les mêmes arguments state et questions que ask(), qui est la méthode client.system_one du SDK Python de TypeSafe avec le modèle figé et l’appel mis en cache, et renvoie la réponse de Jev. Avant chaque appel, elle ajoute à l’état les tickets enregistrés du client et les réponses de Jev correspondantes.

Cette enveloppe est un harness d’agent basique. Un harness est le code autour d’un modèle qui lui donne des capacités supplémentaires, comme les appels d’outils et l’exécution en boucle. Cette version jouet basique ne lui donne que la mémoire, dans un simple dictionnaire Python avec une liste par identifiant de client.

  %%{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

L’enveloppe effectue deux requêtes Jev, l’une après l’autre : la requête d’aiguillage, puis la porte, qui juge le ticket en même temps que la réponse de Jev. L’enveloppe renvoie la réponse d’aiguillage, qu’un souvenir ait été enregistré ou non.

Comme ask_with_memory() prend les mêmes arguments que ask() et renvoie la même réponse, tu peux échanger l’une contre l’autre sans modifier le reste du code. L’enveloppe retrouve les souvenirs du client, les ajoute à l’état et en enregistre de nouveaux elle-même.

L’exemple fait passer cinq tickets antérieurs de deux clients par l’enveloppe, puis aiguille trois messages ultérieurs de chaque client deux fois : une fois avec les souvenirs enregistrés, une fois sans. Un tableau met les deux réponses côte à côte pour les six.

Configuration

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

Définis TYPESAFE_API_KEY. Chaque appel d’API est mis en cache dans json_cache.json. Télécharge-le dans le dossier depuis lequel tu exécutes ce code pour rejouer les chiffres publiés au lieu d’appeler l’API, ou omets-le pour tout exécuter en direct.

Les chiffres ci-dessous proviennent de jev-1.13.0 le 2026-09-28. Le seuil de mémoire de 0,5 est un point de départ. Tu devrais l’évaluer sur tes propres exemples.

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

Définir les tickets

Deux clients, cinq tickets antérieurs et trois messages ultérieurs, tous écrits pour ce cookbook. C-1042 (Harbor Logistics) exécute l’édition auto-hébergée sur Windows Server dans le cadre d’un contrat Enterprise. C-2210 (Fernwood Studio) est sur l’offre cloud self-serve Team. Trois des tickets antérieurs énoncent un fait durable : une édition, un forfait, un contrat. Deux non : un téléphone à l’aéroport, un jour férié. Aucun message ultérieur ne mentionne la configuration du client, donc sans mémoire Jev doit la deviner.

Chaque ticket devient un état à deux parties : customer, qui est le client, et ticket, le fil du ticket. La fonction ticket_state() construit un ticket simplifié, comme un ticket de helpdesk. Dans ton application, l’état est chaque ticket tel que ton helpdesk l’envoie, et ask_with_memory() y ajoute les tickets enregistrés du client. La séparation entre tickets antérieurs et messages ultérieurs ne sert qu’à cet exemple.

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?"
      }
    ]
  }
}

Aiguiller un ticket

Une question Choice choisit l’équipe de support. L’option none_suitable donne à Jev une réponse pour le cas où aucune équipe ne convient, et un ticket trop pauvre en contexte peut y aboutir.

La fonction utilitaire ask() est client.system_one avec la version du modèle figée et chaque appel mis en cache. Elle prend un état et un dictionnaire de questions et renvoie l’objet de réponse du SDK lui-même, donc du code qui lit déjà les réponses de client.system_one fonctionne avec elle sans modification.

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

Le Jev brut envoie les dashboards lents de C-1042 à l’équipe cloud. Ce ticket seul ne lui donne aucune raison de faire autrement.

Demander à Jev si le ticket mérite d’être mémorisé

D’abord, as_memory() associe l’état d’origine à la réponse de Jev : le souvenir que l’enveloppe peut enregistrer. La clé request contient l’état avant l’injection des souvenirs, et jev_answered associe chaque question à sa réponse. Cela évite d’imbriquer les anciens souvenirs dans chaque nouveau souvenir.

Un second appel Jev lit cette paire. La porte demande si la requête énonce un fait important sur le client, comme son édition, son système d’exploitation, son forfait ou son contrat. La réponse de Jev est présente comme contexte, mais un fait qui n’apparaît que dans la réponse ne compte pas. Sans cette règle, une réponse générique comme « General product questions » peut l’emporter sur un fait réel dans la requête, et une réponse qui s’appuyait sur un souvenir antérieur peut être enregistrée de nouveau comme si elle était nouvelle.

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

Envelopper l’appel pour qu’il se souvienne

L’enveloppe, ask_with_memory(), a les mêmes arguments et la même valeur de retour que ask(). Le stockage des souvenirs est un simple dictionnaire avec une liste par identifiant de client. L’enveloppe utilise l’ID dans l’état pour sélectionner les souvenirs du client.

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

Ajouter de la mémoire de cette façon a quatre conséquences pour ton application :

  • Chaque appel effectue deux requêtes séquentielles, ton appel suivi de la porte de mémoire. La porte juge le ticket en même temps que la réponse de Jev, donc elle s’exécute après la requête d’aiguillage. Si ta porte ignore la réponse, elle pourrait plutôt être une seconde question dans la requête d’aiguillage (voir fan-out).
  • La mémoire ne fait que croître. Chaque souvenir enregistré est injecté dans chaque appel ultérieur de ce client. Il n’y a ici aucune limite de taille, aucun contrôle de pertinence et aucune date d’expiration. La section Étapes suivantes donne des idées pour chacun.
  • Tes questions ne mentionnent jamais les souvenirs. Les souvenirs vont dans l’état sous earlier_tickets_from_this_customer, et Jev lit tout l’état. Rien dans ROUTE ne change.
  • L’état a besoin de customer.id. Le Jev brut accepte aussi une chaîne comme état, mais cette enveloppe a besoin de l’ID pour retrouver la liste du client.

Envoyer les tickets antérieurs et observer les réponses changer

Fais passer les cinq tickets antérieurs par ask_with_memory(), dans l’ordre où ils sont arrivés. Le même client renvoie deux des messages ultérieurs : dashboards lents et 20 sièges de plus. Cela montre comment chaque souvenir enregistré modifie les réponses de Jev. Les messages répétés passent eux aussi par l’enveloppe, donc la porte les juge également.

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

Les trois tickets qui énoncent une édition, un forfait ou un contrat sont enregistrés à 0,91–0,92. T-102 est enregistré bien que Jev l’ait aiguillé vers l’équipe générale, car la porte compte les mots du client, pas la réponse. Les tickets de l’aéroport et du jour férié obtiennent 0,07 et 0,10 et ne sont pas enregistrés, donc les réponses qui les suivent ne changent pas.

Chaque souvenir enregistré modifie les réponses auxquelles il s’applique. Pour C-1042, le ticket Windows fait passer les dashboards lents de l’équipe cloud (0,80) à l’équipe Windows (0,99). Le contrat Enterprise fixe ensuite les sièges à 0,99. Pour C-2210, le ticket du forfait Team fait monter l’équipe cloud de 0,75 à 0,91 et déplace les sièges du bureau Enterprise (0,52) vers la facturation (0,98). Ajouter le souvenir Enterprise abaisse légèrement les dashboards lents de C-1042, de 0,99 à 0,94, ce qui est une raison de choisir les souvenirs à ajouter (voir Étapes suivantes). La porte n’a enregistré aucun des messages répétés.

Aiguiller les mêmes messages pour les deux clients

Chaque client envoie maintenant les trois messages ultérieurs. Chaque message passe par le ask() brut et par ask_with_memory(), avec le même état et la même question.

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.

Avec la mémoire, les six messages atteignent l’équipe attendue, contre deux sans. Le même message va désormais à une équipe différente pour chaque client : les dashboards lents vont à l’équipe Windows pour C-1042 et restent à l’équipe cloud pour C-2210, et 20 sièges de plus vont au bureau Enterprise pour C-1042 et à la facturation pour C-2210. Là où le Jev brut avait déjà raison, la mémoire augmente la probabilité, de 0,62 à 0,99 pour les sièges de C-1042. L’enveloppe a aussi jugé les six messages ultérieurs, et n’en a enregistré aucun : ils n’énoncent aucun fait important.

L’équipe attendue de chaque ligne découle de la configuration du client dans les tickets antérieurs : l’édition auto-hébergée et le contrat Enterprise de C-1042, le forfait cloud Team de C-2210.

Ouvre-le dans le playground

Le lien contient l’état d’aiguillage exact utilisé pour le premier appel « dashboards lents » de C-1042, y compris ses souvenirs à ce moment-là, plus la question d’aiguillage.

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})"
))
Ouvre le ticket de C-1042 avec ses souvenirs dans le playground TypeSafe →

Étapes suivantes

  • Choisis ce que ton application doit mémoriser. Modifie GATE pour décrire ce qui mérite d’être mémorisé pour ta propre tâche, et teste REMEMBER_AT sur des exemples que tu as étiquetés.
  • Choisis les souvenirs à ajouter. L’enveloppe ajoute tous les souvenirs enregistrés. Une question de pertinence peut sélectionner un ensemble plus petit une fois la liste devenue longue.
  • Remplace les souvenirs périmés. Demande si un nouveau souvenir remplace un ancien, puis supprime l’entrée ancienne dans le code le cas échéant.
  • Conserve les souvenirs entre les exécutions. Remplace MEMORIES par une base de données indexée par identifiant de client. Le dictionnaire en mémoire disparaît quand le processus se termine.
  • Agis sur l’aiguillage. Associe chaque équipe à un gestionnaire dans le code, par exemple réserver un appel pour les clients Enterprise ou envoyer un article spécifique à la configuration. Voir routage d’intention et routage fondé sur la confiance. Ajoute ta réponse au fil du ticket comme message de support, et la porte pourra mémoriser ce que tu as fait.

Annexe

Une réponse enregistrée peut-elle renforcer une erreur ?

Oui. La porte ignore tout ce qui n’apparaît que dans la réponse de Jev, donc une réponse ne peut pas, à elle seule, faire enregistrer un ticket. Une fois un ticket enregistré, cependant, sa réponse est enregistrée avec lui, inférence erronée comprise, et chaque appel ultérieur de ce client la lit. Une réponse ultérieure peut alors répéter l’erreur.

Comment choisir le seuil ?

Le 0,5 de cette enveloppe est une valeur de départ. Pour choisir le tien, étiquette des paires requête-et-réponse issues de ton trafic comme dignes d’être mémorisées ou non, puis trouve la probabilité qui sépare le mieux les deux groupes. Vérifie-la sur des paires que tu n’as pas utilisées pour la choisir. Augmente-la si un souvenir trompeur coûte plus cher qu’un souvenir manquant ; diminue-la dans le cas inverse. Voir Confiance et Routage conditionné par la confiance pour choisir des seuils et les adapter au risque de chaque action.