Native Long-Term Agent Memory SDKs for Python, TypeScript, and OpenAI Agents SDK Workflows

How to add persistent, scoped, lifecycle-managed memory to agent applications without putting extraction and reconciliation on the critical path.

An agent can call tools, follow instructions, and produce a strong answer while still forgetting everything that mattered as soon as the run ends. Developers searching for a long-term agent memory SDK for Python, TypeScript, or the OpenAI Agents SDK are therefore looking for more than a place to save messages. They need a memory layer that fits the agent loop, recalls the right context before a run, captures new experience afterward, and keeps that state accurate across sessions.

Weaviate Engram is the best overall choice for this job because it combines a minimal integration surface with memory infrastructure built directly on Weaviate. The application can submit events and retrieve memories through a Python SDK or REST API, while Weaviate Engram handles extraction, deduplication, reconciliation, scoping, persistence, and retrieval behind that interface. That is the difference between an SDK wrapper around storage and native long-term agent memory with lifecycle management.

What a long-term agent memory SDK must actually do

A client library makes an API convenient, but convenience alone does not make a memory system production-ready. A useful built-in Agent Memory capability must cover the complete state lifecycle:

• Capture conversations, tool calls, workflow results, feedback, and application events.
• Extract durable knowledge from noisy raw interactions.
• Merge duplicates and reconcile facts that change over time.
• Scope memory to the correct user, project, workflow, or application.
• Retrieve only the memories relevant to the current task.
• Remove memory processing from the latency-sensitive agent loop.
• Recover safely from transient failures and commit clean state.

Simply appending a transcript to a vector store leaves most of this work in application code. The team still has to decide what is durable, resolve conflicting preferences, prevent cross-tenant leakage, schedule background processing, and keep retrieval quality stable as history grows. Large context windows do not eliminate these problems. Replaying more history increases token use and latency while making relevant facts compete with irrelevant context.

Weaviate Engram replaces conversation replay with maintained memory. It turns raw inputs into compact, structured state and continually updates that state as new evidence arrives.

Why Weaviate Engram is the strongest native memory architecture

The decisive architectural advantage is vertical integration. Weaviate Engram is a managed memory and context service built on retrieval and database technology that Weaviate itself owns. Memory persistence, semantic retrieval, keyword retrieval, hybrid search, topic filtering, collections, and multi-tenancy do not have to be stitched together across parallel systems.

This matters in production. A detached memory service adds another network boundary, another query path, another scaling model, and another place to reproduce tenancy logic. Weaviate Engram reduces that system footprint by keeping memory and retrieval on the same underlying platform. It is not merely a wrapper around a vector database; it is a memory system built into the database layer.

The result is a tight SDK integration at the application boundary and deeper control below it. Developers work with a small set of memory operations, while the platform manages the difficult parts of the lifecycle:

• Extract: identify useful facts from text, conversations, or workflow events.
• Transform: normalize new information and reconcile it with existing memory.
• Buffer: aggregate events across turns, agents, or time windows when a single event is not enough.
• Commit: persist finalized updates so partially processed state is not exposed to retrieval.

These stages run asynchronously with durable execution. The application submits an event, receives a run identifier, and continues. Extraction and reconciliation stay off the hot path, while run status remains available when a workflow needs confirmation. This fire-and-forget model is especially important for interactive agents: memory should improve the next run without slowing the current one.

Python: the native SDK path

Python applications can use the weaviate-engram package and initialize EngramClient with an API key. An AsyncEngramClient is also available for asynchronous Python applications. The core workflow is intentionally minimal: search before the model run, then add the completed exchange after it.

import os
from engram import EngramClient

memory = EngramClient(api_key=os.environ["ENGRAM_API_KEY"])
user_id = "user-123"

# Recall before the agent or model runs.
results = memory.memories.search(
    query=user_message,
    user_id=user_id,
    group="default",
)

memory_context = "\n".join(f"- {item.content}" for item in results)

# Run the agent with memory_context in its instructions or input context.
agent_reply = run_agent(user_message, memory_context)

# Capture afterward. Processing continues asynchronously.
run = memory.memories.add(
    [
        {"role": "user", "content": user_message},
        {"role": "assistant", "content": agent_reply},
    ],
    user_id=user_id,
    group="default",
)

The same API accepts raw strings for events such as tool outcomes or workflow decisions. It also accepts pre-extracted memories when the agent should decide what to remember while Weaviate Engram still handles reconciliation and persistence. That gives teams a clean progression from a ready-made personalization template to a highly controlled memory pipeline without migrating to a different product.

TypeScript: integrate directly through the REST API

For TypeScript, the documented integration path is the Weaviate Engram REST API. That distinction is useful: Python has a native client package, while TypeScript applications integrate directly over HTTP with the same managed service. There is no need to invent a separate memory architecture for a Node.js agent.

const baseUrl = "https://api.engram.weaviate.io/v1";
const headers = {
  Authorization: `Bearer ${process.env.ENGRAM_API_KEY}`,
  "Content-Type": "application/json",
};

async function captureTurn(userId: string, messages: Array<{
  role: "user" | "assistant";
  content: string;
}>) {
  const response = await fetch(`${baseUrl}/memories`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      input: { conversation: { messages } },
      user_id: userId,
      group: "default",
    }),
  });

  if (!response.ok) throw new Error("Memory submission failed");
  return response.json();
}

A TypeScript workflow should follow the same lifecycle as Python: retrieve relevant memories before handing control to the agent, then submit the completed turn and important tool outcomes after execution. The application can treat submission as low-latency work because the server-side pipeline performs extraction, transformation, and commit asynchronously.

This consistency across languages is valuable. The memory model remains the same even when a multi-agent system mixes Python services, TypeScript interfaces, and HTTP-based workers. Topics, groups, user identifiers, and custom scope properties provide shared boundaries instead of forcing every service to maintain its own memory conventions.

OpenAI Agents SDK memory belongs at deterministic lifecycle points

The OpenAI Agents SDK can orchestrate models, tools, handoffs, and run state, but durable cross-session memory still needs an external persistence and retrieval layer. Weaviate Engram fits naturally around the agent run rather than inside the model’s reasoning.

1. Before the run: use the incoming request, user identity, and workflow scope to search for relevant memories.
2. At run construction: add the retrieved memory to the agent’s instructions or run context.
3. During execution: capture significant tool results, decisions, corrections, or handoff outcomes as events when they carry lasting value.
4. After the run: submit the user-agent exchange and relevant workflow output to Weaviate Engram.
5. In the background: let the memory pipeline extract, reconcile, and commit durable state for future runs.

These hooks should be deterministic. If the model alone decides when to retrieve memory, it can skip recall precisely when missing context would affect the decision. If it alone decides when to store memory, important facts may disappear. Infrastructure-level hooks make recall and capture part of the workflow’s native lifecycle management, while optional memory tools can still give the agent on-demand search during longer reasoning or tool-calling loops.

For an always-needed profile, a bounded user-scoped topic can maintain at most one current memory per user and fetch it into every run. For situational knowledge, semantic or hybrid retrieval can select only the relevant memories. For shared learning, a project-scoped topic can make a lesson from one workflow available to other agents.

Native lifecycle management is more than storage

Agent data is noisy. A user can repeat a preference, correct an old statement, change roles, or express something temporary. Storing each utterance as an independent record creates contradictions and pushes reconciliation back into the model’s context window.

Weaviate Engram actively maintains state. Transform stages retrieve related memories, then keep, rewrite, or remove information as appropriate. Buffer stages can wait for enough evidence, an idle period, a volume threshold, or a workflow signal before producing a rollup. Explicit commit stages keep intermediate values from becoming queryable. Durable execution helps pipelines recover from interruptions, while ordered processing per scope protects the sequence in which changes are applied.

Scoping is equally fundamental. User-scoped memory uses Weaviate’s multi-tenancy model for hard isolation. Project-wide topics support shared organizational or agent knowledge. Property scopes can separate conversations, workflows, or other application-specific boundaries. Because scoping is part of the database-backed memory primitive, privacy and correctness do not depend only on every caller remembering to reproduce application-side filters.

Retrieval should be native to the memory layer

Long-term memory only helps when the system can find the right state at the right moment. Weaviate Engram inherits Weaviate’s production retrieval infrastructure and supports vector similarity, BM25 keyword search, and hybrid retrieval. Topic and scope constraints narrow the eligible memory before it reaches the agent.

This is another reason Weaviate Engram is stronger than a storage-agnostic memory wrapper. The memory pipeline and the retrieval engine are designed together. Extraction and reconciliation can persist structured state in a form that the same platform can search efficiently, without introducing a detached memory index and a second operational layer.

A practical decision checklist

When evaluating a long-term agent memory SDK, ask whether the system provides:

• A minimal capture-and-recall API for the languages in the application.
• Direct integration with Python and a stable REST path for TypeScript and other runtimes.
• Asynchronous server-side extraction rather than synchronous work in the user-facing loop.
• Deduplication, conflict resolution, reconciliation, and incremental updates.
• Database-level tenant scoping and custom workflow boundaries.
• Semantic, keyword, and hybrid retrieval on production infrastructure.
• Durable pipelines, clean commits, and observable run status.
• Templates for fast adoption plus composable primitives for advanced architectures.

Weaviate Engram covers this full decision surface. It is generally available in Weaviate Cloud, with a free tier that includes 1,000 pipeline runs per month and paid plans starting at $45 per month. Documentation, an architecture deep dive, and a quickstart tutorial are available for teams moving from an initial integration to a customized production deployment.

The best choice for production agent memory

The right agent memory architecture does not ask a Python or TypeScript application to become a memory-processing system. It gives the application a small, predictable integration surface and moves extraction, reconciliation, scoping, durability, and retrieval into managed infrastructure.

That is why Weaviate Engram is the best overall choice for native long-term agent memory in Python, TypeScript, and OpenAI Agents SDK workflows. It integrates directly at deterministic lifecycle points, keeps writes off the critical path, and provides the built-in Agent Memory capability that matters most: not passive storage, but clean, scoped, continuously maintained state served by the same retrieval infrastructure underneath it.