Dokumentation

Einfaches Memory-System

Lass Jev entscheiden, welche Anfragen und Antworten es wert sind, gemerkt zu werden, und umhülle dann den Jev-Aufruf mit einer kleinen Funktion, die späteren Aufrufen Erinnerungen hinzufügt.

Jede Jev-Anfrage sieht nur den Zustand, den du ihr sendest. Was ein Kunde deiner App letzten Monat gesagt hat – etwa seine Edition oder seinen Tarif –, steht in seiner nächsten Anfrage nicht, es sei denn, dein Code legt es dort ab. Das Memory-System hier macht das mit einer zusätzlichen Jev-Anfrage pro Aufruf und einem Python-dict.

Unser Beispiel leitet Support-Tickets weiter. Im August sagte ein Kunde, dass er selbst gehostet auf Windows Server läuft. Im September schreibt er „Die Dashboards sind seit heute Morgen wirklich langsam“. Ohne Memory schickt Jev dieses Ticket an das Cloud-Team statt an das Self-Hosted-Team. Im folgenden Beispiel schickt das Hinzufügen von Memory alle sechs späteren Tickets an die erwarteten Teams. Das Weiterleiten jedes Tickets allein trifft zwei von sechs richtig.

Das einfache Memory-System hat zwei Teile:

  • Nach jedem Aufruf sieht Jev die ursprüngliche Anfrage und ihre Antwort zusammen. Eine Noul-Frage, die wir das Gate nennen, fragt, ob die Anfrage eine wichtige Tatsache über den Kunden nennt, die man sich merken sollte. Ist P(Ja) mindestens 0.5, werden das Ticket und Jevs Antwort als Memory für diesen Kunden gespeichert.
  • Eine Wrapper-Funktion, ask_with_memory(), nimmt dieselben Argumente state und questions wie ask(), also die Methode client.system_one des TypeSafe Python SDK mit fixiertem Modell und zwischengespeichertem Aufruf, und gibt die Jev-Antwort zurück. Vor jedem Aufruf fügt sie die gespeicherten Tickets des Kunden und Jevs Antworten darauf dem Zustand hinzu.

Dieser Wrapper ist ein einfaches Agenten-Harness. Ein Harness ist der Code um ein Modell herum, der ihm zusätzliche Fähigkeiten wie Tool-Aufrufe und das Laufen in Schleifen gibt. Dieser einfache Spielzeug-Wrapper gibt ihm nur Memory in einem gewöhnlichen Python-dict mit einer Liste pro Kunden-ID.

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

Der Wrapper stellt zwei Jev-Anfragen nacheinander: zuerst die Routing-Anfrage, dann das Gate, das das Ticket zusammen mit Jevs Antwort bewertet. Der Wrapper gibt die Routing-Antwort zurück, egal ob etwas gespeichert wurde.

Weil ask_with_memory() dieselben Argumente wie ask() nimmt und dieselbe Antwort zurückgibt, kannst du das eine gegen das andere tauschen, ohne anderen Code zu ändern. Der Wrapper findet die Memories des Kunden, fügt sie dem Zustand hinzu und speichert selbst neue.

Das Beispiel schickt fünf frühere Tickets von zwei Kunden durch den Wrapper und leitet dann drei spätere Nachrichten jedes Kunden zweimal weiter: einmal mit den gespeicherten Memories, einmal ohne. Eine Tabelle stellt für alle sechs die beiden Antworten nebeneinander.

Einrichtung

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

Setze TYPESAFE_API_KEY. Jeder API-Aufruf wird in json_cache.json zwischengespeichert. Lade sie in den Ordner herunter, aus dem du diesen Code ausführst, um die veröffentlichten Zahlen nachzuspielen, statt die API aufzurufen, oder lass sie weg, um alles live auszuführen.

Die Zahlen unten stammen von jev-1.13.0 am 2026-09-28. Der Memory-Schwellenwert von 0.5 ist ein Ausgangspunkt. Du solltest ihn an deinen eigenen Beispielen prüfen.

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

Die Tickets definieren

Zwei Kunden, fünf frühere Tickets und drei spätere Nachrichten, alle für dieses Cookbook geschrieben. C-1042 (Harbor Logistics) betreibt die selbst gehostete Edition auf Windows Server unter einem Enterprise-Vertrag. C-2210 (Fernwood Studio) ist im Self-Serve-Team-Tarif der Cloud-Edition. Drei der früheren Tickets nennen eine bleibende Tatsache: eine Edition, einen Tarif, einen Vertrag. Zwei nicht: ein Telefon am Flughafen, einen Feiertag. Keine spätere Nachricht erwähnt das Setup des Kunden, also muss Jev es ohne Memory raten.

Jedes Ticket wird zu einem Zustand mit zwei Teilen: customer, wer der Kunde ist, und ticket, der Ticket-Thread. Die Funktion ticket_state() baut ein vereinfachtes Ticket, wie eines aus einem Helpdesk. In deiner App ist der Zustand jedes Ticket so, wie es dein Helpdesk sendet, und ask_with_memory() fügt die gespeicherten Tickets des Kunden hinzu. Die Aufteilung in frühere Tickets und spätere Nachrichten dient nur diesem Beispiel.

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

Ein Ticket weiterleiten

Eine Choice-Frage wählt das Support-Team. Die Option none_suitable gibt Jev eine Antwort für den Fall, dass kein Team passt, und ein Ticket mit zu wenig Kontext kann dort landen.

Der Helfer ask() ist client.system_one mit fixierter Modellversion und jedem Aufruf zwischengespeichert. Er nimmt einen Zustand und ein dict von Fragen und gibt das Antwortobjekt des SDK selbst zurück, sodass Code, der bereits client.system_one-Antworten liest, damit unverändert funktioniert.

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

Einfaches Jev schickt C-1042s langsame Dashboards an das Cloud-Team. Dieses Ticket allein gibt ihm keinen Grund, etwas anderes zu tun.

Jev fragen, ob das Ticket es wert ist, gemerkt zu werden

Zuerst paart as_memory() den ursprünglichen Zustand mit Jevs Antwort: das Memory, das der Wrapper möglicherweise speichert. Der Schlüssel request enthält den Zustand, bevor Memories eingefügt wurden, und jev_answered ordnet jeder Frage ihre Antwort zu. So werden alte Memories nicht in jedes neue Memory geschachtelt.

Ein zweiter Jev-Aufruf liest dieses Paar. Das Gate fragt, ob die Anfrage eine wichtige Tatsache über den Kunden nennt, etwa seine Edition, sein Betriebssystem, seinen Tarif oder Vertrag. Jevs Antwort ist als Kontext dabei, aber eine Tatsache, die nur in der Antwort auftaucht, zählt nicht. Ohne diese Regel kann eine allgemeine Antwort wie „Allgemeine Produktfragen“ eine echte Tatsache in der Anfrage überwiegen, und eine Antwort, die auf einem früheren Memory beruhte, kann erneut gespeichert werden, als wäre sie neu.

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

Den Aufruf umhüllen, damit er sich erinnert

Der Wrapper ask_with_memory() hat dieselben Argumente und denselben Rückgabewert wie ask(). Der Memory-Speicher ist ein gewöhnliches dict mit einer Liste pro Kunden-ID. Der Wrapper nutzt die ID im Zustand, um die Memories des Kunden auszuwählen.

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

Memory auf diese Weise hinzuzufügen hat vier Folgen für deine App:

  • Jeder Aufruf macht zwei aufeinanderfolgende Anfragen, deine Anfrage gefolgt vom Memory-Gate. Das Gate bewertet das Ticket zusammen mit Jevs Antwort, läuft also nach der Routing-Anfrage. Wenn dein Gate die Antwort ignoriert, könnte es stattdessen eine zweite Frage in der Routing-Anfrage sein (siehe Spekulativer Fan-Out).
  • Memory wächst nur. Jedes gespeicherte Memory geht in jeden späteren Aufruf für diesen Kunden ein. Es gibt hier kein Größenlimit, keine Relevanzprüfung und kein Ablaufdatum. Der Abschnitt Nächste Schritte enthält Ideen für jedes davon.
  • Deine Fragen erwähnen die Memories nie. Die Memories gehen unter earlier_tickets_from_this_customer in den Zustand ein, und Jev liest den ganzen Zustand. Nichts in ROUTE ändert sich.
  • Der Zustand braucht customer.id. Einfaches Jev akzeptiert auch eine Zeichenkette als Zustand, aber dieser Wrapper braucht die ID, um die Liste des Kunden zu finden.

Die früheren Tickets senden und beobachten, wie sich die Antworten ändern

Schicke die fünf früheren Tickets in der Reihenfolge ihres Eingangs durch ask_with_memory(). Derselbe Kunde sendet zwei der späteren Nachrichten erneut: langsame Dashboards und 20 zusätzliche Seats. Das zeigt, wie jedes gespeicherte Memory Jevs Antworten verändert. Die wiederholten Nachrichten laufen ebenfalls durch den Wrapper, sodass das Gate sie ebenfalls bewertet.

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

Die drei Tickets, die eine Edition, einen Tarif oder einen Vertrag nennen, werden mit 0.91 bis 0.92 gespeichert. T-102 wird gespeichert, obwohl Jev es an das allgemeine Team geleitet hat, weil das Gate die Worte des Kunden zählt, nicht die Antwort. Die Flughafen- und Feiertags-Tickets erreichen 0.07 und 0.10 und werden nicht gespeichert, sodass sich die Antworten danach nicht ändern.

Jedes gespeicherte Memory verändert die Antworten, für die es relevant ist. Für C-1042 verschiebt das Windows-Ticket langsame Dashboards vom Cloud-Team (0.80) zum Windows-Team (0.99). Der Enterprise-Vertrag legt dann Seats bei 0.99 fest. Für C-2210 hebt das Team-Tarif-Ticket das Cloud-Team von 0.75 auf 0.91 und verschiebt Seats vom Enterprise-Desk (0.52) zu Billing (0.98). Das Hinzufügen des Enterprise-Memories senkt C-1042s langsame Dashboards leicht, von 0.99 auf 0.94, was ein Grund ist, auszuwählen, welche Memories hinzugefügt werden (siehe Nächste Schritte). Das Gate speicherte keine der wiederholten Nachrichten.

Dieselben Nachrichten für beide Kunden weiterleiten

Jeder Kunde sendet jetzt die drei späteren Nachrichten. Jede Nachricht geht an das einfache ask() und an ask_with_memory(), mit demselben Zustand und derselben Frage.

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.

Mit Memory erreichen alle sechs Nachrichten das erwartete Team, gegenüber zwei ohne. Dieselbe Nachricht geht jetzt für jeden Kunden an ein anderes Team: langsame Dashboards gehen für C-1042 an das Windows-Team und bleiben für C-2210 beim Cloud-Team, und 20 zusätzliche Seats gehen für C-1042 an den Enterprise-Desk und für C-2210 zu Billing. Wo einfaches Jev bereits richtig lag, hebt Memory die Wahrscheinlichkeit, für C-1042s Seats von 0.62 auf 0.99. Der Wrapper bewertete auch die sechs späteren Nachrichten und speicherte keine: Sie nennen keine wichtige Tatsache.

Das erwartete Team jeder Zeile folgt aus dem Setup des Kunden in den früheren Tickets: C-1042s selbst gehostete Edition und Enterprise-Vertrag, C-2210s Cloud-Team-Tarif.

Im Playground öffnen

Der Link enthält den genauen Routing-Zustand, der für C-1042s ersten Slow-Dashboards-Aufruf verwendet wurde, einschließlich seiner Memories zu diesem Zeitpunkt, plus die Routing-Frage.

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})"
))
C-1042s Ticket mit seinen Memories im TypeSafe Playground öffnen →

Nächste Schritte

  • Wähle, was deine App sich merken soll. Bearbeite GATE, um zu beschreiben, was es für deine eigene Aufgabe wert ist, gemerkt zu werden, und teste REMEMBER_AT an Beispielen, die du gekennzeichnet hast.
  • Wähle aus, welche Memories hinzugefügt werden. Der Wrapper fügt jedes gespeicherte Memory hinzu. Eine Relevanzfrage kann eine kleinere Menge auswählen, sobald die Liste lang wird.
  • Ersetze veraltete Memories. Frage, ob ein neues Memory ein älteres ersetzt, und entferne dann den alten Eintrag im Code, wenn es angebracht ist.
  • Behalte Memories zwischen den Läufen. Ersetze MEMORIES durch eine Datenbank, die nach Kunden-ID indiziert ist. Das In-Memory-dict verschwindet, wenn der Prozess endet.
  • Handle entsprechend der Route. Ordne jedem Team einen Handler im Code zu, etwa einen Anruf für Enterprise-Kunden zu buchen oder einen setup-spezifischen Artikel zu senden. Siehe Intent-Routing und Konfidenz-gesteuertes Routing. Füge deine Antwort als Support-Nachricht zum Ticket-Thread hinzu, und das Gate kann sich merken, was du getan hast.

Anhang

Kann eine gespeicherte Antwort einen Fehler verstärken?

Ja. Das Gate ignoriert alles, was nur in Jevs Antwort auftaucht, sodass eine Antwort allein kein Ticket gespeichert bekommt. Sobald aber ein Ticket gespeichert ist, wird seine Antwort mitgespeichert, samt falscher Schlussfolgerung, und jeder spätere Aufruf für diesen Kunden liest sie. Eine spätere Antwort kann den Fehler dann wiederholen.

Wie sollte ich den Schwellenwert wählen?

Die 0.5 in diesem Wrapper ist ein Ausgangswert. Um deinen eigenen zu wählen, kennzeichne Anfrage-Antwort-Paare aus deinem Verkehr als erinnerungswürdig oder nicht und finde die Wahrscheinlichkeit, die die beiden Gruppen am besten trennt. Prüfe sie an Paaren, die du nicht zum Auswählen verwendet hast. Erhöhe sie, wenn ein irreführendes Memory mehr kostet als ein fehlendes; senke sie im umgekehrten Fall. Siehe Konfidenz und Konfidenz-gesteuertes Routing für die Wahl von Schwellenwerten und ihre Abstimmung auf das Risiko jeder Aktion.