Документация

Простая система памяти

Позвольте Jev решать, какие запросы и ответы стоит запоминать, а затем оберните вызов Jev в небольшую функцию, которая добавляет воспоминания к последующим вызовам.

Каждый запрос к Jev видит только то состояние, которое вы ему отправили. То, что клиент сказал вашему приложению в прошлом месяце — например, свою редакцию или план, — не окажется в его следующем запросе, если ваш код не положит это туда. Здешняя система памяти делает это одним дополнительным запросом к Jev на вызов и словарём Python.

Наш пример маршрутизирует тикеты поддержки. В августе клиент сказал, что разворачивает решение самостоятельно на Windows Server. В сентябре он пишет: «Дашборды с самого утра очень медленные». Без памяти Jev отправляет этот тикет в облачную команду вместо команды самостоятельного развёртывания. В примере ниже добавление памяти отправляет все шесть последующих тикетов в ожидаемые команды. Маршрутизация каждого тикета по отдельности даёт два правильных из шести.

Простая система памяти состоит из двух частей:

  • После каждого вызова Jev видит исходный запрос и свой ответ вместе. Вопрос Noul, который мы называем воротами, спрашивает, утверждает ли запрос важный факт о клиенте, который стоит запомнить. Если P(да) не меньше 0.5, тикет и ответ Jev сохраняются как воспоминание об этом клиенте.
  • Функция-обёртка, ask_with_memory(), принимает те же аргументы state и questions, что и ask(), — это метод client.system_one из TypeSafe Python SDK с закреплённой моделью и кэшированным вызовом, — и возвращает ответ Jev. Перед каждым вызовом она добавляет сохранённые тикеты клиента и ответы Jev на них в состояние.

Эта обёртка — базовый harness для агента. Harness — это код вокруг модели, который даёт ей дополнительные возможности, такие как вызовы инструментов и работа в циклах. Этот базовый игрушечный вариант даёт ей лишь память в обычном словаре Python с одним списком на идентификатор клиента.

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

Обёртка делает два запроса к Jev, один за другим: запрос маршрутизации, затем ворота, которые судят тикет вместе с ответом Jev. Обёртка возвращает ответ маршрутизации независимо от того, сохранилось ли что-нибудь.

Поскольку ask_with_memory() принимает те же аргументы, что и ask(), и возвращает тот же ответ, вы можете заменить одно на другое, не меняя никакой другой код. Обёртка сама находит воспоминания клиента, добавляет их в состояние и сохраняет новые.

Пример пропускает пять ранних тикетов от двух клиентов через обёртку, а затем дважды маршрутизирует по три поздних сообщения от каждого клиента: один раз с сохранёнными воспоминаниями, один раз без них. Таблица ставит два ответа рядом для всех шести.

Настройка

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

Задайте TYPESAFE_API_KEY. Каждый вызов API кэшируется в json_cache.json. Скачайте его в папку, из которой запускаете этот код, чтобы воспроизвести опубликованные числа вместо вызова API, или не скачивайте, чтобы всё шло вживую.

Числа ниже получены на jev-1.13.0 28.09.2026. Порог памяти 0.5 — это отправная точка. Вам стоит оценить его на собственных примерах.

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

Определите тикеты

Два клиента, пять ранних тикетов и три поздних сообщения, все написаны для этого cookbook. C-1042 (Harbor Logistics) разворачивает самостоятельную редакцию на Windows Server по корпоративному контракту Enterprise. C-2210 (Fernwood Studio) находится на облачной редакции по самообслуживаемому плану Team. Три из ранних тикетов утверждают долговечный факт: редакцию, план, контракт. Два — нет: телефон в аэропорту, государственный праздник. Ни одно позднее сообщение не упоминает настройку клиента, поэтому без памяти Jev приходится её угадывать.

Каждый тикет становится состоянием из двух частей: customer — кто клиент, и ticket — ветка тикета. Функция ticket_state() строит упрощённый тикет, вроде тех, что приходят из службы поддержки. В вашем приложении состояние — это каждый тикет таким, каким его отправляет ваша служба поддержки, а ask_with_memory() добавляет к нему сохранённые тикеты клиента. Разделение на ранние тикеты и поздние сообщения — только для этого примера.

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

Маршрутизируйте тикет

Один вопрос Choice выбирает команду поддержки. Вариант none_suitable даёт Jev ответ на случай, когда ни одна команда не подходит, и тикет со слишком малым контекстом может попасть туда.

Помощник ask() — это client.system_one с зафиксированной версией модели и кэшированием каждого вызова. Он принимает состояние и словарь вопросов и возвращает собственный объект ответа SDK, поэтому код, который уже читает ответы client.system_one, работает с ним без изменений.

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 отправляет медленные дашборды C-1042 в облачную команду. Один этот тикет не даёт ему никакой причины поступить иначе.

Спросите Jev, стоит ли запомнить тикет

Сначала as_memory() связывает исходное состояние с ответом Jev: это воспоминание, которое обёртка может сохранить. Ключ request содержит состояние до того, как в него добавили воспоминания, а jev_answered сопоставляет каждый вопрос его ответу. Это не даёт старым воспоминаниям вкладываться в каждое новое.

Второй вызов Jev читает эту пару. Ворота спрашивают, утверждает ли запрос важный факт о клиенте, такой как его редакция, операционная система, план или контракт. Ответ Jev там как контекст, но факт, который появляется только в ответе, не считается. Без этого правила общий ответ вроде «Общие вопросы о продукте» может перевесить настоящий факт в запросе, и ответ, опиравшийся на более раннее воспоминание, может быть сохранён снова как будто он новый.

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

Оберните вызов так, чтобы он помнил

У обёртки ask_with_memory() те же аргументы и возвращаемое значение, что и у ask(). Хранилище памяти — обычный словарь с одним списком на идентификатор клиента. Обёртка использует ID в состоянии, чтобы выбрать воспоминания этого клиента.

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

Добавление памяти таким способом имеет четыре следствия для вашего приложения:

  • Каждый вызов делает два последовательных запроса — ваш вызов, затем ворота памяти. Ворота судят тикет вместе с ответом Jev, поэтому они выполняются после запроса маршрутизации. Если ваши ворота игнорируют ответ, их вместо этого можно сделать вторым вопросом в запросе маршрутизации (см. спекулятивный fan-out).
  • Память только растёт. Каждое сохранённое воспоминание попадает в каждый последующий вызов для этого клиента. Здесь нет ограничения размера, проверки на релевантность и срока истечения. В разделе «Дальнейшие шаги» есть идеи для каждого.
  • Ваши вопросы никогда не упоминают воспоминания. Воспоминания попадают в состояние под ключом earlier_tickets_from_this_customer, и Jev читает всё состояние. Ничто в ROUTE не меняется.
  • Состоянию нужен customer.id. Обычный Jev тоже принимает строку как состояние, но этой обёртке нужен ID, чтобы найти список клиента.

Отправьте ранние тикеты и посмотрите, как меняются ответы

Пропустите пять ранних тикетов через ask_with_memory() в порядке их поступления. Тот же клиент отправляет два поздних сообщения снова: медленные дашборды и 20 дополнительных мест. Это показывает, как каждое сохранённое воспоминание меняет ответы Jev. Повторные сообщения проходят через обёртку тоже, поэтому ворота судят и их.

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

Три тикета, которые утверждают редакцию, план или контракт, сохраняются с 0.91 до 0.92. T-102 сохраняется, хотя Jev направил его в общую команду, потому что ворота считают слова клиента, а не ответ. Тикеты про аэропорт и государственный праздник набирают 0.07 и 0.10 и не сохраняются, поэтому ответы после них не меняются.

Каждое сохранённое воспоминание меняет те ответы, к которым оно относится. Для C-1042 тикет про Windows сдвигает медленные дашборды из облачной команды (0.80) в команду Windows (0.99). Затем корпоративный контракт закрепляет места на 0.99. Для C-2210 тикет про план Team поднимает облачную команду с 0.75 до 0.91 и переводит места из корпоративного отдела (0.52) в биллинг (0.98). Добавление корпоративного воспоминания немного понижает медленные дашборды C-1042, с 0.99 до 0.94, — это одна из причин выбирать, какие воспоминания добавлять (см. «Дальнейшие шаги»). Ворота не сохранили ни одного из повторных сообщений.

Маршрутизируйте одни и те же сообщения для обоих клиентов

Теперь каждый клиент отправляет три поздних сообщения. Каждое сообщение идёт в обычный ask() и в ask_with_memory(), с тем же состоянием и тем же вопросом.

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.

С памятью все шесть сообщений достигают ожидаемой команды против двух без неё. Одно и то же сообщение теперь идёт в разные команды для каждого клиента: медленные дашборды идут в команду Windows для C-1042 и остаются в облачной команде для C-2210, а 20 дополнительных мест идут в корпоративный отдел для C-1042 и в биллинг для C-2210. Там, где обычный Jev был уже прав, память повышает вероятность, с 0.62 до 0.99 для мест C-1042. Обёртка также судила шесть поздних сообщений и не сохранила ни одного: они не утверждают никакого важного факта.

Ожидаемая команда в каждой строке следует из настройки клиента в ранних тикетах: самостоятельная редакция и корпоративный контракт C-1042, облачный план Team у C-2210.

Откройте это в песочнице

Ссылка содержит точное состояние маршрутизации, использованное для первого вызова C-1042 про медленные дашборды, включая его воспоминания на тот момент, плюс вопрос маршрутизации.

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-1042 с его воспоминаниями в песочнице TypeSafe →

Дальнейшие шаги

  • Выберите, что должно помнить ваше приложение. Измените GATE, чтобы описать, что стоит запоминать для вашей задачи, и проверьте REMEMBER_AT на размеченных вами примерах.
  • Выберите, какие воспоминания добавлять. Обёртка добавляет каждое сохранённое воспоминание. Вопрос о релевантности может выбрать меньший набор, когда список станет длинным.
  • Заменяйте устаревшие воспоминания. Спросите, заменяет ли новое воспоминание старое, затем при необходимости удалите старую запись в коде.
  • Сохраняйте память между запусками. Замените MEMORIES базой данных с ключом по идентификатору клиента. Словарь в памяти исчезает при завершении процесса.
  • Действуйте по маршруту. Сопоставьте каждую команду обработчику в коде, например назначьте звонок для корпоративных клиентов или отправьте статью под конкретную настройку. См. маршрутизацию по намерению и маршрутизацию на основе уверенности. Добавьте свой ответ в ветку тикета как сообщение поддержки, и ворота смогут запомнить, что вы сделали.

Приложение

Может ли сохранённый ответ закрепить ошибку?

Да. Ворота игнорируют всё, что появляется только в ответе Jev, поэтому ответ сам по себе не может привести к сохранению тикета. Но как только тикет сохранён, его ответ сохраняется вместе с ним, вместе с ошибочным выводом, и каждый последующий вызов для этого клиента его читает. Тогда более поздний ответ может повторить ошибку.

Как мне выбрать порог?

0.5 в этой обёртке — отправное значение. Чтобы выбрать своё, разметьте пары «запрос–ответ» из вашего трафика как достойные запоминания или нет и найдите вероятность, которая лучше всего разделяет две группы. Проверьте её на парах, которые вы не использовали для выбора. Повысьте её, если вводящее в заблуждение воспоминание стоит дороже пропущенного; понизьте, если наоборот. См. Уверенность и маршрутизация по уверенности, чтобы выбирать пороги и согласовывать их с риском каждого действия.