Remember conversation turns - Tex | Memory API for agents

Use tex.conversations.remember to store new conversation turns. This is the write side of the loop from the Quickstart.

RememberResponse = tex.conversations.remember(
    turns: list[dict],
    *,
    session_id: str,
    metadata: dict | None = None,
) -> RememberResponse

Parameters

list[dict]

required

List of turn dicts. At least one turn is required. Empty lists return 422. Each turn:

{
  "role": "user" | "assistant" | str,   # any free-form role
  "text": "the thing said",
  "timestamp": "2026-01-12T14:00:00Z",  # ISO 8601, UTC preferred
  "observations": [...],                 # optional, see below
}

str

required

The conversation, channel, or task this batch belongs to.

dict | None

Free-form metadata attached to the batch. Deep mode can use it during search.

Returns

str | None

Stable identifier for this write. Use it to match SDK logs with server logs.

list[str]

IDs of the active-memory fragments. These are recallable right away.

str | None

Reserved for future async passive job tracking. Currently always null.

Usage | None

tokens_in / tokens_out for this call. tokens_out is typically 0 on remember. Always present in production.

Examples

Single user turn

tex.conversations.remember(
    session_id="chat-1",
    turns=[
        {
            "role": "user",
            "text": "I prefer Python over JavaScript.",
            "timestamp": "2026-05-08T10:00:00Z",
        },
    ],
)

Both sides of a turn

tex.conversations.remember(
    session_id="chat-1",
    turns=[
        {"role": "user",      "text": user_msg,   "timestamp": now_iso()},
        {"role": "assistant", "text": assistant_msg, "timestamp": now_iso()},
    ],
)

Backfill historical conversation

turns = [
    {"role": t["role"], "text": t["text"], "timestamp": t["ts"]}
    for t in db.fetch_chat_history(conv_id)
]

# One big batch is far cheaper than per-turn calls
tex.conversations.remember(session_id=f"chat-{conv_id}", turns=turns)

Pre-extracted observations

If your app already extracted structured facts, pass them inline:

turns = [{
    "role": "user",
    "text": "I'm allergic to shellfish.",
    "timestamp": "2026-05-08T10:00:00Z",
    "observations": [
        {"type": "preference", "predicate": "avoids", "value": "shellfish"},
    ],
}]

tex.conversations.remember(session_id="chat-1", turns=turns)

Behavior

Active write

The call returns after active memory is saved, usually around 150ms. The turn is recallable right away.

Background enrichment

Tex extracts observations and entities in the background. They appear in later recalls.

Best practices

Batch. Pass dozens of turns in one call. Don’t loop one-per-turn.
Use UTC ISO 8601 for timestamps (...Z suffix). This keeps temporal queries clear.
Skip system messages. They consume tokens and add noise to recall.
Run remember off the request path. Use Celery, RQ, or a BackgroundTasks queue when users should not wait.

Idempotency

Tex computes a stable hash per turn from text, timestamp, and role. Re-sending the same turn is a no-op. It does not create duplicate active memory or double bill the same turn. This makes retries safe after a network blip.

Next: Recall

Pull the relevant slice of memory.

​Parameters

​Returns

​Examples

​Single user turn

​Both sides of a turn

​Backfill historical conversation

​Pre-extracted observations

​Behavior

​Best practices

​Idempotency