Sistema de memória simples
Deixa a Jev decidir que pedidos e respostas vale a pena recordar e depois envolve a chamada à Jev numa pequena função que acrescenta memórias às chamadas seguintes.
Cada pedido à Jev vê apenas o estado que lhe envias. O que um cliente disse à tua aplicação no mês passado, como a sua edição ou o seu plano, não está no seu pedido seguinte a menos que o teu código o coloque lá. O sistema de memória aqui faz isso com um pedido extra à Jev por chamada e um dicionário Python.
O nosso exemplo encaminha tickets de suporte. Em agosto, um cliente disse que auto-aloja a sua edição no Windows Server. Em setembro escreve “Os dashboards estão muito lentos desde esta manhã”. Sem memória, a Jev envia esse ticket para a equipa da nuvem em vez da equipa auto-alojada. No exemplo abaixo, acrescentar memória envia todos os seis tickets seguintes para as equipas esperadas. Encaminhar cada ticket isoladamente acerta em dois de seis.
O sistema de memória simples tem duas partes:
- Depois de cada chamada, a Jev vê o pedido original e a sua resposta em conjunto. Uma
pergunta
Noul, a que chamamos gate, pergunta se o pedido enuncia um facto importante sobre o cliente que deve ser recordado. Se P(sim) for pelo menos 0,5, o ticket e a resposta da Jev são guardados como memória para esse cliente. - Uma função wrapper,
ask_with_memory(), recebe os mesmos argumentosstateequestionsqueask(), que é o métodoclient.system_onedo SDK de Python da TypeSafe com o modelo fixado e a chamada em cache, e devolve a resposta da Jev. Antes de cada chamada, acrescenta ao estado os tickets guardados do cliente e as respostas que a Jev lhes deu.
Esse wrapper é um harness de agente básico. Um harness é o código em torno de um modelo que lhe dá capacidades extra, como chamadas a ferramentas e execução em ciclos. Este básico, de brinquedo, só lhe dá memória num dicionário Python simples, com uma lista por ID de cliente.
%%{init: {"fontFamily": "Inter, sans-serif", "flowchart": {"rankSpacing": 25, "wrappingWidth": 300, "subGraphTitleMargin": {"top": 8, "bottom": 20}}}}%%
flowchart TB
IN["ask_with_memory(state, questions)"]
subgraph R["Jev: answer the question"]
Q1["<b>Choice:</b> which support team?"]
end
subgraph G["Jev: judge the routed ticket"]
Q2["<b>Noul:</b> does the request state<br/>an important fact about the customer?"]
end
DEC{"P(yes) ≥ 0.5?<br/>your code"}
SAVE["save the memory<br/>under this customer's ID"]
OUT["handle the support ticket response in your code"]
MEM[("MEMORIES<br/>saved memories per customer")]
IN -- "state with memories<br/>+ routing question" --> R
R -- "original request + answer<br/>+ memory question" --> G
G -- "P(yes)" --> DEC
DEC -- "yes: save" --> SAVE
DEC -- "no: don't save" --> OUT
SAVE --> OUT
SAVE --> MEM
IN -. "added to the state<br/>on this customer's<br/>next support tickets" .- MEM
O wrapper faz dois pedidos à Jev, um a seguir ao outro: o pedido de encaminhamento e depois o gate, que julga o ticket em conjunto com a resposta da Jev. O wrapper devolve a resposta de encaminhamento, quer algo seja guardado quer não.
Como ask_with_memory() recebe os mesmos argumentos que ask() e devolve a mesma resposta,
podes trocar um pelo outro sem alterar mais nenhum código. O wrapper encontra as memórias do
cliente, acrescenta-as ao estado e guarda ele mesmo as novas.
O exemplo envia cinco tickets anteriores de dois clientes pelo wrapper e depois encaminha três mensagens posteriores de cada cliente duas vezes: uma com as memórias que guardou, outra sem. Uma tabela põe as duas respostas lado a lado para os seis.
Configuração
pip install ipython 'cooksafe>=0.2.0,<0.3.0'
Define TYPESAFE_API_KEY. Cada chamada à API fica em cache em
json_cache.json.
Descarrega-o para a pasta a partir da qual corres este código, para reproduzires os números
publicados em vez de chamares a API, ou deixa-o de fora para correr tudo ao vivo.
Os números abaixo vieram do jev-1.13.0 em 2026-09-28.
O limiar de memória de 0,5 é um ponto de partida. Deves avaliá-lo com
os teus próprios exemplos.
import json
import os
from pathlib import Path
from cooksafe import JsonCache, make_playground_link
from IPython.display import Markdown, display
from typesafe_sdk import Choice, Noul, NoulCriteria, SystemOneResponse, TypeSafeClient
TYPESAFE_MODEL = "jev-1.13.0"
REMEMBER_AT = 0.5 # save when P(lasting customer fact) reaches this starting threshold
MEMORY_KEY = "earlier_tickets_from_this_customer" # where saved tickets go in the state
client = TypeSafeClient(
api_key=os.environ.get("TYPESAFE_API_KEY", "cache-only"), # keyless kernels replay the cache
base_url=os.environ.get("TYPESAFE_ENDPOINT"),
timeout=120.0,
)
json_cache = JsonCache(Path("json_cache.json"))
Define os tickets
Dois clientes, cinco tickets anteriores e três mensagens posteriores, todos escritos para este cookbook. A C-1042 (Harbor Logistics) corre a edição auto-alojada no Windows Server ao abrigo de um contrato Enterprise. A C-2210 (Fernwood Studio) está na edição de nuvem, no plano Team self-serve. Três dos tickets anteriores enunciam um facto duradouro: uma edição, um plano, um contrato. Dois não: um telefone no aeroporto, um feriado. Nenhuma mensagem posterior menciona a configuração do cliente, por isso, sem memória, a Jev tem de a adivinhar.
Cada ticket torna-se um estado com duas partes: customer, quem é o cliente, e ticket, o
fio do ticket. A função ticket_state() constrói um ticket simplificado, como um de um
helpdesk. Na tua aplicação, o estado é cada ticket tal como o teu helpdesk o envia, e
ask_with_memory() acrescenta-lhe os tickets guardados do cliente. A divisão em tickets
anteriores e mensagens posteriores é só para este exemplo.
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?"
}
]
}
}
Encaminha um ticket
Uma pergunta Choice escolhe a equipa de suporte. A opção none_suitable dá à Jev uma
resposta para quando nenhuma equipa serve, e um ticket com demasiado pouco contexto pode
acabar aí.
O auxiliar ask() é o client.system_one com a versão do modelo fixada e cada chamada em
cache. Recebe um estado e um dicionário de perguntas e devolve o próprio objeto de resposta do
SDK, por isso o código que já lê respostas de client.system_one funciona com ele sem
alterações.
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
A Jev simples envia os dashboards lentos da C-1042 para a equipa da nuvem. Este ticket isolado não lhe dá motivo para fazer outra coisa.
Pergunta à Jev se vale a pena recordar o ticket
Primeiro, as_memory() emparelha o estado original com a resposta da Jev: a memória que o
wrapper pode guardar. A chave request contém o estado antes de as memórias serem injetadas,
e jev_answered mapeia cada pergunta à sua resposta. Isto evita que memórias antigas fiquem
aninhadas dentro de cada memória nova.
Uma segunda chamada à Jev lê esse par. O gate pergunta se o pedido enuncia um facto importante sobre o cliente, como a sua edição, sistema operativo, plano ou contrato. A resposta da Jev está lá como contexto, mas um facto que apareça apenas na resposta não conta. Sem essa regra, uma resposta genérica como “General product questions” pode sobrepor-se a um facto real no pedido, e uma resposta que se apoiou numa memória anterior pode ser guardada outra vez como se fosse nova.
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
Envolve a chamada para que se lembre
O wrapper, ask_with_memory(), tem os mesmos argumentos e o mesmo valor de retorno que
ask(). O armazenamento de memórias é um dicionário simples com uma lista por ID de cliente.
O wrapper usa o ID no estado para selecionar as memórias do cliente.
MEMORIES: dict[str, list[dict]] = {} # customer ID -> that customer's saved memories
def customer_id(state: dict) -> str:
return state["customer"]["id"]
def ask_with_memory(state: dict, questions: dict) -> SystemOneResponse:
"""ask(), plus memory: same arguments, same return value."""
# 1. Answer the call with this customer's existing memories.
saved = MEMORIES.get(customer_id(state), [])
response = ask({**state, MEMORY_KEY: saved} if saved else state, questions)
# 2. Ask Jev whether the original request states an important fact worth keeping.
memory = as_memory(state, questions, response)
if remember_probability(memory) >= REMEMBER_AT:
MEMORIES.setdefault(customer_id(state), []).append(memory)
return response
Acrescentar memória desta forma tem quatro consequências para a tua aplicação:
- Cada chamada faz dois pedidos sequenciais, a tua chamada seguida do gate de memória. O gate julga o ticket em conjunto com a resposta da Jev, por isso corre depois do pedido de encaminhamento. Se o teu gate ignorar a resposta, podia ser antes uma segunda pergunta no pedido de encaminhamento (vê fan-out).
- A memória só cresce. Cada memória guardada entra em todas as chamadas posteriores desse cliente. Aqui não há limite de tamanho, nem verificação de relevância, nem data de expiração. A secção Passos seguintes tem ideias para cada um.
- As tuas perguntas nunca mencionam as memórias. As memórias entram no estado sob
earlier_tickets_from_this_customer, e a Jev lê o estado inteiro. Nada emROUTEmuda. - O estado precisa de
customer.id. A Jev simples também aceita uma cadeia de caracteres como estado, mas este wrapper precisa do ID para encontrar a lista do cliente.
Envia os tickets anteriores e vê as respostas mudar
Envia os cinco tickets anteriores pelo ask_with_memory(), pela ordem em que chegaram. O
mesmo cliente volta a enviar duas das mensagens posteriores: dashboards lentos e mais 20
lugares. Isto mostra como cada memória guardada altera as respostas da Jev. As mensagens
repetidas também passam pelo wrapper, por isso o gate também as julga.
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
Os três tickets que enunciam uma edição, um plano ou um contrato são guardados a 0,91–0,92. O T-102 é guardado mesmo que a Jev o tenha encaminhado para a equipa geral, porque o gate conta as palavras do cliente, não a resposta. Os tickets do aeroporto e do feriado pontuam 0,07 e 0,10 e não são guardados, por isso as respostas a seguir a eles não mudam.
Cada memória guardada altera as respostas a que é relevante. Para a C-1042, o ticket do Windows move os dashboards lentos da equipa da nuvem (0,80) para a equipa Windows (0,99). O contrato Enterprise fixa então os lugares em 0,99. Para a C-2210, o ticket do plano Team sobe a equipa da nuvem de 0,75 para 0,91 e move os lugares da Enterprise desk (0,52) para billing (0,98). Acrescentar a memória Enterprise baixa ligeiramente os dashboards lentos da C-1042, de 0,99 para 0,94, o que é uma razão para escolher que memórias acrescentar (vê Passos seguintes). O gate não guardou nenhuma das mensagens repetidas.
Encaminha as mesmas mensagens para ambos os clientes
Cada cliente envia agora as três mensagens posteriores. Cada mensagem vai para o ask()
simples e para o ask_with_memory(), com o mesmo estado e a mesma pergunta.
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.
Com memória, as seis mensagens chegam à equipa esperada, contra duas sem ela. A mesma mensagem vai agora para uma equipa diferente em cada cliente: os dashboards lentos vão para a equipa Windows na C-1042 e ficam na equipa da nuvem na C-2210, e mais 20 lugares vão para a Enterprise desk na C-1042 e para billing na C-2210. Onde a Jev simples já estava certa, a memória sobe a probabilidade, de 0,62 para 0,99 nos lugares da C-1042. O wrapper também julgou as seis mensagens posteriores e não guardou nenhuma: não enunciam nenhum facto importante.
A equipa esperada de cada linha decorre da configuração do cliente nos tickets anteriores: a edição auto-alojada e o contrato Enterprise da C-1042, o plano Team de nuvem da C-2210.
Abre-o no playground
O link contém o estado de encaminhamento exato usado na primeira chamada de dashboards lentos da C-1042, incluindo as suas memórias nesse ponto, mais a pergunta de encaminhamento.
playground_link = make_playground_link(example_state, ROUTE, models=[TYPESAFE_MODEL])
display(Markdown(
f"🔗 [Open C-1042's ticket with its memories in the TypeSafe playground]({playground_link})"
))
Abre o ticket da C-1042 com as suas memórias no playground da TypeSafe →
Passos seguintes
- Escolhe o que a tua aplicação deve recordar. Edita o
GATEpara descrever o que vale a pena recordar na tua própria tarefa, e testa oREMEMBER_ATcom exemplos que tenhas rotulado. - Escolhe que memórias acrescentar. O wrapper acrescenta todas as memórias guardadas. Uma pergunta de relevância pode selecionar um conjunto mais pequeno quando a lista ficar longa.
- Substitui memórias desatualizadas. Pergunta se uma memória nova substitui uma mais antiga e depois remove a entrada antiga no código quando for caso disso.
- Mantém as memórias entre execuções. Substitui o
MEMORIESpor uma base de dados indexada por ID de cliente. O dicionário em memória desaparece quando o processo termina. - Age sobre o encaminhamento. Mapeia cada equipa para um manipulador no código, como marcar uma chamada para clientes Enterprise ou enviar um artigo específico da configuração. Vê encaminhamento por intenção e encaminhamento baseado na confiança. Acrescenta a tua resposta ao fio do ticket como uma mensagem de suporte, e o gate pode recordar o que fizeste.
Apêndice
Uma resposta guardada pode reforçar um erro?
Sim. O gate ignora tudo o que aparece apenas na resposta da Jev, por isso uma resposta não consegue, sozinha, fazer guardar um ticket. Uma vez guardado um ticket, porém, a sua resposta é guardada com ele, com a inferência errada e tudo, e todas as chamadas posteriores desse cliente leem-na. Uma resposta posterior pode então repetir o erro.
Como devo escolher o limiar?
O 0,5 neste wrapper é um valor de partida. Para escolheres o teu, rotula pares de pedido-e-resposta do teu tráfego como dignos de memória ou não, e encontra a probabilidade que melhor separa os dois grupos. Verifica-a em pares que não usaste para a escolher. Sobe-o se uma memória enganadora custar mais do que uma em falta; baixa-o se for ao contrário. Vê Confiança e Confidence-Gated Routing para escolheres limiares e os ajustares ao risco de cada ação.