Tokia
Entrar
Documentação
⌘K

Chatbot com Memoria

Um chatbot sem memoria esquece tudo a cada mensagem. Esta receita mostra como manter historico de conversa, limitar o contexto quando fica grande, e usar sessions do Tokia para agrupar interacoes.

Chatbot basico (Python)

O historico e uma lista de mensagens que cresce a cada turno:

python
from openai import OpenAI

client = OpenAI(
    base_url="https://api.usetokia.com/v1",
    api_key="sk-...",
)

history: list[dict] = [
    {"role": "system", "content": "Voce e um assistente de suporte da loja XYZ."},
]

def chat(user_message: str) -> str:
    history.append({"role": "user", "content": user_message})

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=history,
    )

    assistant_msg = response.choices[0].message.content or ""
    history.append({"role": "assistant", "content": assistant_msg})
    return assistant_msg

print(chat("Qual o prazo de entrega?"))
print(chat("E se atrasar?"))
print(chat("Voce lembra o que eu perguntei primeiro?"))

Janela deslizante (sliding window)

A cada turno o historico cresce. Modelos tem limite de contexto (ex: 128K tokens para GPT-4o mini). A estrategia mais simples: manter apenas as ultimas N mensagens:

python
MAX_MESSAGES = 20

def chat_windowed(user_message: str) -> str:
    history.append({"role": "user", "content": user_message})

    window = [history[0]] + history[-MAX_MESSAGES:]

    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=window,
    )

    assistant_msg = response.choices[0].message.content or ""
    history.append({"role": "assistant", "content": assistant_msg})
    return assistant_msg

Resumo automatico (context compression)

Para conversas longas, resuma as mensagens antigas em vez de descartar:

python
SUMMARY_THRESHOLD = 30

def summarize_history() -> None:
    if len(history) < SUMMARY_THRESHOLD:
        return

    old_messages = history[1:-10]
    conversation_text = "\n".join(
        f"{m['role']}: {m['content']}" for m in old_messages
    )

    summary_response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[
            {
                "role": "user",
                "content": (
                    "Resuma a conversa abaixo em 3-5 pontos-chave. "
                    "Mantenha nomes, numeros e decisoes.\n\n"
                    f"{conversation_text}"
                ),
            },
        ],
    )

    summary = summary_response.choices[0].message.content or ""

    del history[1:-10]
    history.insert(1, {
        "role": "system",
        "content": f"Resumo da conversa anterior:\n{summary}",
    })

Versao TypeScript (Node.js)

typescript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.usetokia.com/v1",
  apiKey: process.env.TOKIA_API_KEY,
});

type Message = { role: "system" | "user" | "assistant"; content: string };

const history: Message[] = [
  { role: "system", content: "Voce e um assistente de suporte." },
];

async function chat(userMessage: string): Promise<string> {
  history.push({ role: "user", content: userMessage });

  const response = await client.chat.completions.create({
    model: "gpt-4o-mini",
    messages: history,
  });

  const reply = response.choices[0]?.message.content ?? "";
  history.push({ role: "assistant", content: reply });
  return reply;
}

Sessions do Tokia

O Tokia agrupa chamadas por session_id. Passe o header ou parametro extra para acompanhar a conversa nos logs de sessions:

python
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=history,
    extra_body={"session_id": "user-123-conversa-1"},
)

O session_id aparece nos logs do dashboard, facilitando debug e auditoria de conversas individuais.

Persistir historico

Para manter o historico entre reinicializacoes do servidor, salve em banco de dados (PostgreSQL, Redis, DynamoDB) ou arquivo JSON. Estrutura minima:

  • Chave: user_id + conversation_id
  • Valor: lista de mensagens (JSON)
  • TTL: 7-30 dias (evita crescimento infinito)

Proximos passos