Memory

Select frameworks to compare

Pick one or more frameworks from the bar above

Memory

OpenAI

from openai import OpenAI

LLM_MODEL = "gpt-5.4"
client = OpenAI()

# turn 1
response = client.responses.create(
    model=LLM_MODEL,
    input="What is the capital of France?",
)
print(response.output_text)
# "The capital of France is Paris."

# turn 2 — previous_response_id continues the conversation server-side
response = client.responses.create(
    model=LLM_MODEL,
    previous_response_id=response.id,
    input=[{"role": "user", "content": "What is its population?"}],
)
print(response.output_text)
# "The population of Paris is approximately 2.1 million..."

Anthropic

import anthropic

LLM_MODEL = "claude-opus-4-6"
client = anthropic.Anthropic()

# Anthropic has no built-in memory — store messages yourself
store: dict[str, list] = {}

def chat(thread_id: str, message: str) -> str:
    history = store.get(thread_id, [])
    history.append({"role": "user", "content": message})
    response = client.messages.create(
        model=LLM_MODEL, max_tokens=1024, messages=history,
    )
    history.append({"role": "assistant", "content": response.content})
    store[thread_id] = history
    return response.content[0].text

# turn 1
print(chat("chat_1", "What is the capital of France?"))
# "The capital of France is Paris."

# turn 2 — same thread, history is restored from the store
print(chat("chat_1", "What is its population?"))
# "The population of Paris is approximately 2.1 million..."

Gemini

from google import genai

LLM_MODEL = "gemini-pro-latest"
client = genai.Client()

# chat session manages history — just send the next message
chat = client.chats.create(model=LLM_MODEL)

# turn 1
response = chat.send_message("What is the capital of France?")
print(response.text)
# "The capital of France is Paris."

# turn 2 — chat session remembers the conversation
response = chat.send_message("What is its population?")
print(response.text)
# "The population of Paris is approximately 2.1 million..."

Pydantic AI

from pydantic_ai import Agent

LLM_MODEL = "openai:gpt-5.4"
agent = Agent(LLM_MODEL)

# Pydantic AI has no built-in memory — store messages yourself
store: dict[str, list] = {}

def chat(thread_id: str, message: str) -> str:
    history = store.get(thread_id, [])
    result = agent.run_sync(message, message_history=history)
    store[thread_id] = result.new_messages()
    return result.output

# turn 1
print(chat("chat_1", "What is the capital of France?"))
# "The capital of France is Paris."

# turn 2 — same thread, history is restored from the store
print(chat("chat_1", "What is its population?"))
# "The population of Paris is approximately 2.1 million..."

LangGraph

from langchain.agents import create_agent
from langchain_openai import ChatOpenAI
from langgraph.checkpoint.memory import MemorySaver

LLM_MODEL = "gpt-5.4"
model = ChatOpenAI(model=LLM_MODEL)

# checkpointer persists state — same thread_id restores history
checkpointer = MemorySaver()
agent = create_agent(model, tools=[], checkpointer=checkpointer)

config = {"configurable": {"thread_id": "chat_1"}}

# turn 1
result = agent.invoke(
    {"messages": [("user", "What is the capital of France?")]},
    config=config,
)
print(result["messages"][-1].content)
# "The capital of France is Paris."

# turn 2 — same thread_id, checkpointer restores history automatically
result = agent.invoke(
    {"messages": [("user", "What is its population?")]},
    config=config,
)
print(result["messages"][-1].content)
# "The population of Paris is approximately 2.1 million..."

AI SDK

import { generateText, type ModelMessage } from "ai";
import { openai } from "@ai-sdk/openai";

const LLM_MODEL = "gpt-5.4";

// AI SDK has no built-in memory — store messages yourself
const store: Record<string, ModelMessage[]> = {};

async function chat(threadId: string, message: string): Promise<string> {
  const history = store[threadId] ?? [];
  history.push({ role: "user", content: message });
  const result = await generateText({ model: openai(LLM_MODEL), messages: history });
  history.push({ role: "assistant", content: result.text });
  store[threadId] = history;
  return result.text;
}

// turn 1
console.log(await chat("chat_1", "What is the capital of France?"));
// "The capital of France is Paris."

// turn 2 — same thread, history is restored from the store
console.log(await chat("chat_1", "What is its population?"));
// "The population of Paris is approximately 2.1 million..."

Mastra

import { Agent } from "@mastra/core/agent";
import { Memory } from "@mastra/memory";

const LLM_MODEL = "openai/gpt-5.4";

// Memory manages conversation state — same thread restores history
const agent = new Agent({
  name: "assistant",
  instructions: "You are a helpful assistant.",
  model: LLM_MODEL,
  memory: new Memory(),
});

const memoryConfig = { memory: { thread: "chat_1", resource: "user_1" } };

// turn 1
const result1 = await agent.generate(
  "What is the capital of France?",
  memoryConfig,
);
console.log(result1.text);
// "The capital of France is Paris."

// turn 2 — same thread, memory restores history automatically
const result2 = await agent.generate(
  "What is its population?",
  memoryConfig,
);
console.log(result2.text);
// "The population of Paris is approximately 2.1 million..."

History Compaction

OpenAI

from openai import OpenAI

LLM_MODEL = "gpt-5.4"
client = OpenAI()

# sliding window: keep last N messages, discard everything older
# cheapest — zero latency, but complete context loss beyond the window
WINDOW = 10
messages: list = []

def chat(message: str) -> str:
    messages.append({"role": "user", "content": message})
    # only send the last WINDOW messages
    window = messages[-WINDOW:]
    response = client.responses.create(model=LLM_MODEL, input=window)
    messages.append({"role": "assistant", "content": response.output_text})
    return response.output_text

print(chat("What is the capital of France?"))
print(chat("What is its population?"))

from openai import OpenAI

LLM_MODEL = "gpt-5.4"
client = OpenAI()

# token-aware compaction: API auto-compresses when input exceeds threshold
# old assistant messages and tool calls are replaced with encrypted compaction
# items — user messages are always kept verbatim

response = client.responses.create(
    model=LLM_MODEL,
    input="What is the capital of France?",
)
print(response.output_text)

# context_management auto-triggers compaction when tokens exceed threshold
response = client.responses.create(
    model=LLM_MODEL,
    previous_response_id=response.id,
    input=[{"role": "user", "content": "What is its population?"}],
    context_management=[
        {"type": "compaction", "compact_threshold": 100_000}
    ],
)
print(response.output_text)

from openai import OpenAI

LLM_MODEL = "gpt-5.4"
SUMMARY_MODEL = "gpt-5-mini"  # cheap model for summaries
client = OpenAI()

# explicit compaction via previous_response_id
# builds server-side conversation state, then compacts it on demand
# gives full control over when compaction happens — call between turns

# turn 1 — kick off the conversation
response = client.responses.create(
    model=LLM_MODEL,
    input="What is the capital of France?",
)
print(response.output_text)
# "The capital of France is Paris."

# turn 2 — previous_response_id chains the conversation server-side
response = client.responses.create(
    model=LLM_MODEL,
    previous_response_id=response.id,
    input=[{"role": "user", "content": "What is its population?"}],
)
print(response.output_text)
# "Approximately 2.1 million in the city proper."

# compact — model compresses the full thread into a shorter context
compacted = client.responses.compact(
    model=SUMMARY_MODEL,
    previous_response_id=response.id,
)

# normalize compacted output to plain dicts before the next call
# avoids PydanticSerializationUnexpectedValue warnings from the SDK
context = []
for item in compacted.output:
    if item.type == "message":
        context.append({"role": item.role, "content": item.content[0].text})
    else:
        context.append(item.model_dump(exclude_unset=True))

# continue with compacted context — old turns are summarized, not lost
response = client.responses.create(
    model=LLM_MODEL,
    input=[
        *context,
        {"role": "user", "content": "And the metro area?"},
    ],
)
print(response.output_text)

Anthropic

import anthropic

LLM_MODEL = "claude-opus-4-6"
client = anthropic.Anthropic()

# sliding window: keep last N messages, discard everything older
# cheapest — zero latency, but complete context loss beyond the window
WINDOW = 10
messages: list = []

def chat(message: str) -> str:
    messages.append({"role": "user", "content": message})
    # only send the last WINDOW messages
    window = messages[-WINDOW:]
    response = client.messages.create(
        model=LLM_MODEL, max_tokens=1024, messages=window,
    )
    messages.append({"role": "assistant", "content": response.content})
    return response.content[0].text

print(chat("What is the capital of France?"))
print(chat("What is its population?"))

import anthropic

LLM_MODEL = "claude-opus-4-6"
client = anthropic.Anthropic()

# token-aware compaction: API auto-compacts when input tokens exceed trigger
# replaces old messages with an LLM-generated summary (beta feature)
# on subsequent requests, messages before the compaction block are auto-dropped

messages: list = []

def chat(message: str) -> str:
    messages.append({"role": "user", "content": message})
    response = client.beta.messages.create(
        betas=["compact-2026-01-12"],
        model=LLM_MODEL,
        max_tokens=1024,
        messages=messages,
        context_management={
            "edits": [{
                "type": "compact_20260112",
                "trigger": {"type": "input_tokens", "value": 100_000},
            }]
        },
    )
    # response may include compaction blocks — append as-is
    messages.append({"role": "assistant", "content": response.content})
    return response.content[0].text

print(chat("What is the capital of France?"))
print(chat("What is its population?"))

import anthropic

LLM_MODEL = "claude-opus-4-6"
client = anthropic.Anthropic()

# compaction with pause: API compacts then pauses so you can inspect
# the summary before continuing — gives full control over the process
# custom instructions guide what the summary should preserve

messages: list = []

def chat(message: str) -> str:
    messages.append({"role": "user", "content": message})
    response = client.beta.messages.create(
        betas=["compact-2026-01-12"],
        model=LLM_MODEL,
        max_tokens=1024,
        messages=messages,
        context_management={
            "edits": [{
                "type": "compact_20260112",
                "trigger": {"type": "input_tokens", "value": 100_000},
                "pause_after_compaction": True,
                "instructions": "Preserve key facts, decisions, and code snippets.",
            }]
        },
    )
    messages.append({"role": "assistant", "content": response.content})
    # if compaction triggered, stop_reason is "compaction" — resume to continue
    if response.stop_reason == "compaction":
        response = client.beta.messages.create(
            betas=["compact-2026-01-12"],
            model=LLM_MODEL,
            max_tokens=1024,
            messages=messages,
        )
        messages.append({"role": "assistant", "content": response.content})
    return response.content[0].text

print(chat("What is the capital of France?"))
print(chat("What is its population?"))

Gemini

from google import genai
from google.genai import types

LLM_MODEL = "gemini-pro-latest"
client = genai.Client()

# sliding window: keep last N messages, discard everything older
# cheapest — zero latency, but complete context loss beyond the window
# can't use chat.send_message() here — it manages history internally
WINDOW = 10
history: list[types.Content] = []

def chat(message: str) -> str:
    history.append(types.Content(role="user", parts=[types.Part(text=message)]))
    window = history[-WINDOW:]
    response = client.models.generate_content(
        model=LLM_MODEL, contents=window,
    )
    history.append(types.Content(role="model", parts=[types.Part(text=response.text)]))
    return response.text

print(chat("What is the capital of France?"))
print(chat("What is its population?"))

from google import genai
from google.genai import types

LLM_MODEL = "gemini-pro-latest"
client = genai.Client()

# token-aware: count tokens and only trim when approaching context limit
# Gemini supports up to 2M tokens — trimming is less urgent but still
# good practice for long-running conversations
WINDOW = 10
TOKEN_LIMIT = 100_000
history: list[types.Content] = []

def chat(message: str) -> str:
    history.append(types.Content(role="user", parts=[types.Part(text=message)]))
    # count actual tokens — no guessing needed
    token_count = client.models.count_tokens(
        model=LLM_MODEL, contents=history,
    )
    window = history
    if token_count.total_tokens > TOKEN_LIMIT:
        window = history[-WINDOW:]  # approaching limit — keep recent only
    response = client.models.generate_content(
        model=LLM_MODEL, contents=window,
    )
    history.append(types.Content(role="model", parts=[types.Part(text=response.text)]))
    return response.text

print(chat("What is the capital of France?"))
print(chat("What is its population?"))

from google import genai
from google.genai import types

LLM_MODEL = "gemini-pro-latest"
SUMMARY_MODEL = "gemini-flash-latest"  # cheap model for summaries
client = genai.Client()

# summarization: compress old messages with a cheap model
# no built-in compaction API — call a fast model to summarize,
# then replace old messages with the summary
WINDOW = 10
history: list[types.Content] = []

def summarize_old(messages: list[types.Content]) -> list[types.Content]:
    if len(messages) <= 20:
        return messages  # short enough — no compression needed
    old, recent = messages[:-WINDOW], messages[-WINDOW:]
    summary = client.models.generate_content(
        model=SUMMARY_MODEL,
        contents=[
            types.Content(role="user", parts=[types.Part(
                text=f"Summarize this conversation in 2-3 sentences. "
                f"Preserve key facts and decisions.\n\n{old}",
            )]),
        ],
    )
    return [
        types.Content(role="user", parts=[types.Part(
            text=f"[Summary of earlier conversation]: {summary.text}",
        )]),
        *recent,
    ]

def chat(message: str) -> str:
    history.append(types.Content(role="user", parts=[types.Part(text=message)]))
    window = summarize_old(history)
    response = client.models.generate_content(
        model=LLM_MODEL, contents=window,
    )
    history.append(types.Content(role="model", parts=[types.Part(text=response.text)]))
    return response.text

print(chat("What is the capital of France?"))
print(chat("What is its population?"))

Pydantic AI

from pydantic_ai import Agent
from pydantic_ai.messages import ModelMessage

LLM_MODEL = "openai:gpt-5.4"

# sliding window: keep last N messages, discard everything older
# processor runs before each model call, replaces history for that call
WINDOW = 10

def sliding_window(messages: list[ModelMessage]) -> list[ModelMessage]:
    return messages[-WINDOW:]

agent = Agent(LLM_MODEL, history_processors=[sliding_window])

history: list[ModelMessage] = []

result = agent.run_sync("What is the capital of France?", message_history=history)
history = result.new_messages()
print(result.output)

result = agent.run_sync("What is its population?", message_history=history)
history = result.new_messages()
print(result.output)

from pydantic_ai import Agent, RunContext
from pydantic_ai.messages import ModelMessage

LLM_MODEL = "openai:gpt-5.4"

# token-aware: trim only when approaching the context window limit
# short conversations stay intact, long ones get pruned
# RunContext gives access to accumulated token usage

def token_trim(
    ctx: RunContext[None], messages: list[ModelMessage],
) -> list[ModelMessage]:
    if ctx.usage.total_tokens > 100_000:
        return messages[-10:]  # approaching limit — keep recent only
    return messages  # still fits — keep everything

agent = Agent(LLM_MODEL, history_processors=[token_trim])

history: list[ModelMessage] = []

result = agent.run_sync("What is the capital of France?", message_history=history)
history = result.new_messages()
print(result.output)

result = agent.run_sync("What is its population?", message_history=history)
history = result.new_messages()
print(result.output)

import asyncio
from pydantic_ai import Agent, ModelMessage

LLM_MODEL = "openai:gpt-5.4"
SUMMARY_MODEL = "openai:gpt-5-mini"  # cheap model for summaries

# summarization: compress old messages with a cheap model
# most expensive — adds latency and cost, but preserves context
# the processor fires before each model call automatically

summarize_agent = Agent(
    SUMMARY_MODEL,
    instructions="Summarize this conversation in 2-3 sentences. "
    "Preserve key facts, decisions, and open questions.",
)

async def summarize_old(messages: list[ModelMessage]) -> list[ModelMessage]:
    if len(messages) <= 10:
        return messages  # short enough — no compression needed
    oldest = messages[:-6]
    recent = messages[-6:]
    # pass structured messages via message_history — not a stringified prompt
    summary = await summarize_agent.run(message_history=oldest)
    # new_messages() returns properly formed ModelMessage objects
    return summary.new_messages() + recent

agent = Agent(LLM_MODEL, history_processors=[summarize_old])

async def main():
    history: list[ModelMessage] = []
    for prompt in [
        "What is the capital of France?",
        "What is its population?",
        "And the metro area?",
    ]:
        result = await agent.run(prompt, message_history=history)
        history = result.all_messages()
        print(result.output)

asyncio.run(main())

LangGraph

from langchain.agents import create_agent
from langchain.agents.middleware import before_model
from langchain_openai import ChatOpenAI
from langchain_core.messages import RemoveMessage
from langgraph.graph.message import REMOVE_ALL_MESSAGES
from langgraph.checkpoint.memory import MemorySaver

LLM_MODEL = "gpt-5.4"
model = ChatOpenAI(model=LLM_MODEL)

# sliding window: keep last N messages via @before_model middleware
# runs before every model call — trims checkpointed state in-place
WINDOW = 10

@before_model
def sliding_window(state, runtime):
    messages = state["messages"]
    if len(messages) <= WINDOW:
        return None  # short enough — no trimming needed
    # remove all, then re-add only the recent window
    return {
        "messages": [
            RemoveMessage(id=REMOVE_ALL_MESSAGES),
            *messages[-WINDOW:],
        ]
    }

agent = create_agent(
    model, tools=[], middleware=[sliding_window],
    checkpointer=MemorySaver(),
)

config = {"configurable": {"thread_id": "chat_1"}}

result = agent.invoke(
    {"messages": [("user", "What is the capital of France?")]},
    config=config,
)
print(result["messages"][-1].content)

result = agent.invoke(
    {"messages": [("user", "What is its population?")]},
    config=config,
)
print(result["messages"][-1].content)

from langchain.agents import create_agent
from langchain.agents.middleware import before_model
from langchain_openai import ChatOpenAI
from langchain_core.messages import RemoveMessage
from langgraph.graph.message import REMOVE_ALL_MESSAGES
from langgraph.checkpoint.memory import MemorySaver

LLM_MODEL = "gpt-5.4"
model = ChatOpenAI(model=LLM_MODEL)

# token-aware: only trim when message count exceeds threshold
# short conversations stay intact — middleware returns None to skip
THRESHOLD = 50
WINDOW = 10

@before_model
def token_trim(state, runtime):
    messages = state["messages"]
    if len(messages) <= THRESHOLD:
        return None  # fits — keep everything
    # approaching limit — keep first message (system) + recent window
    return {
        "messages": [
            RemoveMessage(id=REMOVE_ALL_MESSAGES),
            messages[0],
            *messages[-WINDOW:],
        ]
    }

agent = create_agent(
    model, tools=[], middleware=[token_trim],
    checkpointer=MemorySaver(),
)

config = {"configurable": {"thread_id": "chat_1"}}

result = agent.invoke(
    {"messages": [("user", "What is the capital of France?")]},
    config=config,
)
print(result["messages"][-1].content)

result = agent.invoke(
    {"messages": [("user", "What is its population?")]},
    config=config,
)
print(result["messages"][-1].content)

from langchain.agents import create_agent
from langchain.agents.middleware import SummarizationMiddleware
from langgraph.checkpoint.memory import MemorySaver

LLM_MODEL = "gpt-5.4"
SUMMARY_MODEL = "gpt-5-mini"  # cheap model for summaries

# built-in summarization middleware — compresses old messages automatically
# triggers when the conversation exceeds a token threshold
# keeps recent messages intact, summarizes everything older
# uses a cheap model for compression to minimize cost

agent = create_agent(
    model=LLM_MODEL,
    tools=[],
    middleware=[
        SummarizationMiddleware(
            model=SUMMARY_MODEL,
            trigger=("tokens", 4000),      # compress when context exceeds 4k tokens
            keep=("messages", 10),         # preserve the 10 most recent messages
        ),
    ],
    checkpointer=MemorySaver(),
)

config = {"configurable": {"thread_id": "chat_1"}}

result = agent.invoke(
    {"messages": [("user", "What is the capital of France?")]},
    config=config,
)
print(result["messages"][-1].content)

result = agent.invoke(
    {"messages": [("user", "What is its population?")]},
    config=config,
)
print(result["messages"][-1].content)

AI SDK

import { generateText, type ModelMessage } from "ai";
import { openai } from "@ai-sdk/openai";

const LLM_MODEL = "gpt-5.4";

// sliding window: keep last N messages, discard everything older
// cheapest — zero latency, but complete context loss beyond the window
const WINDOW = 10;
const messages: ModelMessage[] = [];

async function chat(message: string): Promise<string> {
  messages.push({ role: "user", content: message });
  const window = messages.slice(-WINDOW);
  const result = await generateText({
    model: openai(LLM_MODEL),
    messages: window,
  });
  messages.push({ role: "assistant", content: result.text });
  return result.text;
}

console.log(await chat("What is the capital of France?"));
console.log(await chat("What is its population?"));

import { generateText, type ModelMessage } from "ai";
import { openai } from "@ai-sdk/openai";

const LLM_MODEL = "gpt-5.4";

// token-aware: only trim when approaching context limit
// estimate tokens from content length — AI SDK has no built-in token counter
const TOKEN_LIMIT = 100_000;
const CHARS_PER_TOKEN = 4; // rough estimate
const messages: ModelMessage[] = [];

function estimateTokens(msgs: ModelMessage[]): number {
  return msgs.reduce(
    (sum, m) => sum + String(m.content).length / CHARS_PER_TOKEN,
    0,
  );
}

async function chat(message: string): Promise<string> {
  messages.push({ role: "user", content: message });
  // short conversations stay intact, long ones get pruned
  let window: ModelMessage[] = messages;
  if (estimateTokens(messages) > TOKEN_LIMIT) {
    window = messages.slice(-10); // approaching limit — keep recent only
  }
  const result = await generateText({
    model: openai(LLM_MODEL),
    messages: window,
  });
  messages.push({ role: "assistant", content: result.text });
  return result.text;
}

console.log(await chat("What is the capital of France?"));
console.log(await chat("What is its population?"));

import { generateText, pruneMessages, type ModelMessage } from "ai";
import { openai } from "@ai-sdk/openai";

const LLM_MODEL = "gpt-5.4";
const SUMMARY_MODEL = "gpt-5-mini"; // cheap model for summaries

// summarization: prune tool/reasoning bloat, then compress old messages
// pruneMessages is built-in (strips tool calls and reasoning content)
// LLM summarization is manual — uses a cheap model for compression
const messages: ModelMessage[] = [];

async function compactHistory(msgs: ModelMessage[]): Promise<ModelMessage[]> {
  // step 1: strip old tool calls and reasoning — built-in, zero-cost
  const pruned = pruneMessages({
    messages: msgs,
    reasoning: "before-last-message",
    toolCalls: "before-last-2-messages",
  });
  if (pruned.length <= 20) return pruned;
  // step 2: still too long — summarize older messages with a cheap model
  const old = pruned.slice(0, -10);
  const recent = pruned.slice(-10);
  const { text } = await generateText({
    model: openai(SUMMARY_MODEL),
    messages: [
      {
        role: "user",
        content:
          "Summarize this conversation in 2-3 sentences. " +
          `Preserve key facts and decisions.\n\n${JSON.stringify(old)}`,
      },
    ],
  });
  return [{ role: "assistant", content: `[Summary]: ${text}` }, ...recent];
}

async function chat(message: string): Promise<string> {
  messages.push({ role: "user", content: message });
  const compacted = await compactHistory(messages);
  const result = await generateText({
    model: openai(LLM_MODEL),
    messages: compacted,
  });
  messages.push({ role: "assistant", content: result.text });
  return result.text;
}

console.log(await chat("What is the capital of France?"));
console.log(await chat("What is its population?"));

Mastra

import { Agent } from "@mastra/core/agent";
import { Memory } from "@mastra/memory";

const LLM_MODEL = "openai/gpt-5.4";

// sliding window: keep last N messages, discard everything older
// built into Memory — one config option, no custom code needed
const agent = new Agent({
  name: "assistant",
  instructions: "You are a helpful assistant.",
  model: LLM_MODEL,
  memory: new Memory({
    options: { lastMessages: 10 },
  }),
});

const memoryConfig = { memory: { thread: "chat_1", resource: "user_1" } };

const result1 = await agent.generate(
  "What is the capital of France?",
  memoryConfig,
);
console.log(result1.text);

const result2 = await agent.generate(
  "What is its population?",
  memoryConfig,
);
console.log(result2.text);

import { Agent } from "@mastra/core/agent";
import { Memory } from "@mastra/memory";

const LLM_MODEL = "openai/gpt-5.4";

// token-aware: generous window + semantic recall for important older context
// lastMessages limits what's sent to the model each turn
// semanticRecall retrieves relevant older messages beyond the window,
// so important context isn't lost after trimming
const agent = new Agent({
  name: "assistant",
  instructions: "You are a helpful assistant.",
  model: LLM_MODEL,
  memory: new Memory({
    options: {
      lastMessages: 40,
      semanticRecall: { topK: 3, messageRange: 2 },
    },
  }),
});

const memoryConfig = { memory: { thread: "chat_1", resource: "user_1" } };

const result1 = await agent.generate(
  "What is the capital of France?",
  memoryConfig,
);
console.log(result1.text);

const result2 = await agent.generate(
  "What is its population?",
  memoryConfig,
);
console.log(result2.text);

import { Agent } from "@mastra/core/agent";
import { Memory } from "@mastra/memory";

const LLM_MODEL = "openai/gpt-5.4";

// observational memory: background agents compress conversation automatically
// observer watches for token growth, creates concise notes (5-40x compression)
// reflector further condenses when observations accumulate
// no compaction pause — runs transparently alongside normal conversation
const agent = new Agent({
  name: "assistant",
  instructions: "You are a helpful assistant.",
  model: LLM_MODEL,
  memory: new Memory({
    options: {
      lastMessages: 20,
      observationalMemory: true,
    },
  }),
});

const memoryConfig = { memory: { thread: "chat_1", resource: "user_1" } };

const result1 = await agent.generate(
  "What is the capital of France?",
  memoryConfig,
);
console.log(result1.text);

const result2 = await agent.generate(
  "What is its population?",
  memoryConfig,
);
console.log(result2.text);