Mastra Memory

npm install memorysync-mastra @mastra/core

import { Agent } from "@mastra/core/agent";
import { openai } from "@ai-sdk/openai";
import { createMemorySyncProcessors } from "memorysync-mastra";

const { inputProcessor, outputProcessor } = createMemorySyncProcessors({
  userId: "customer-7",     // per-end-user scoping
  sessionId: "thread-42",   // groups the stored transcript
});

const agent = new Agent({
  id: "assistant",
  name: "Assistant",
  instructions: "You are a helpful assistant.",
  model: openai("gpt-4o-mini"),
  inputProcessors: [inputProcessor],
  outputProcessors: [outputProcessor],
});

// First conversation
await agent.generate("I'm vegetarian and I fly aisle.");

// Any later call — same user, any thread, any model
const { text } = await agent.generate(
  "Book my trip: flight plus a dinner spot.",
);
// The model already saw: vegetarian, aisle seat — injected from memory.

import { Agent } from "@mastra/core/agent";
import { openai } from "@ai-sdk/openai";
import { withMemorySync } from "memorysync-mastra";

const agent = new Agent(withMemorySync(
  {
    id: "assistant",
    name: "Assistant",
    instructions: "You are a helpful assistant.",
    model: openai("gpt-4o-mini"),
  },
  { userId: "customer-7" },
));
// Identical behaviour to wiring the processors yourself. Your own
// input/output processors are preserved — MemorySync's run after them.

import { RequestContext } from "@mastra/core/request-context";
import {
  createMemorySyncProcessors,
  MASTRA_RESOURCE_ID_KEY,
  MASTRA_THREAD_ID_KEY,
} from "memorysync-mastra";

// 1. Your own resolver — wins over everything (multi-user servers).
createMemorySyncProcessors({
  resolveIdentity: (requestContext) => ({
    userId: currentSession.userId,
    sessionId: currentSession.threadId,
  }),
});

// 2. Static ids — one agent per user (scripts, workers).
createMemorySyncProcessors({ userId: "customer-7", sessionId: "thread-42" });

// 3. Mastra's RequestContext — set by your server middleware.
const ctx = new RequestContext();
ctx.set(MASTRA_RESOURCE_ID_KEY, "customer-7");
ctx.set(MASTRA_THREAD_ID_KEY, "thread-42");
await agent.generate(messages, { requestContext: ctx });

// 4. Mastra's own memory plumbing — the ids ride the call.
await agent.generate("I moved to Lisbon.", {
  memory: { resource: "customer-7", thread: "thread-42" },
});

const stream = await agent.stream("Plan a dinner for my team.", {
  memory: { resource: "customer-7", thread: "thread-42" },
});

for await (const chunk of stream.textStream) {
  process.stdout.write(chunk);
}
// Persistence runs once, after the full stream — chunk latency is
// untouched.

// Recall shape — pick per agent:
createMemorySyncProcessors({ userId, mode: "query" });   // relevant to the latest message (default)
createMemorySyncProcessors({ userId, mode: "profile" }); // stable overview of the user
createMemorySyncProcessors({ userId, mode: "full" });    // both

// Read-only agent: recalls context, never writes anything.
createMemorySyncProcessors({ userId, persist: false });

// Write-only agent: persists exchanges, injects nothing.
createMemorySyncProcessors({ userId, recall: false });

// Tune recall depth and the injected block's shape.
createMemorySyncProcessors({
  userId,
  k: 12,
  template: "What you know about this user:\n{context}",
});

import { Agent } from "@mastra/core/agent";
import { createMemorySyncTools } from "memorysync-mastra";

const agent = new Agent({
  id: "assistant",
  name: "Assistant",
  instructions: "Use the memory tools to remember durable facts.",
  model: openai("gpt-4o-mini"),
  tools: { ...createMemorySyncTools({ userId: "customer-7" }) },
});

await agent.generate("Remember that I prefer aisle seats.");

// Untrusted agents: search + list only.
createMemorySyncTools({ userId: "customer-7", readOnly: true });

import {
  getMemoryContext,
  saveTurn,
  searchMemories,
} from "memorysync-mastra";

// 1. Prompt-ready context block ("" for a new user)
const context = await getMemoryContext("what should I cook?", {
  userId: "customer-7",
});

// 2. Scored raw results
const hits = await searchMemories("dietary preferences", {
  userId: "customer-7",
});
// [{ id: "m_123", text: "human: I'm vegetarian", score: 0.62 }, ...]

// 3. Explicit persistence — THROWS on failure (an explicit call is
//    owed the truth), unlike the processors' reported-never-thrown.
await saveTurn(
  { user: "I'm vegetarian", assistant: "Noted!", sessionId: "thread-42" },
  { userId: "customer-7" },
);