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 Argumentestateundquestionswieask(), also die Methodeclient.system_onedes 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_customerin den Zustand ein, und Jev liest den ganzen Zustand. Nichts inROUTEä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 testeREMEMBER_ATan 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
MEMORIESdurch 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.