@mastra/memory 1.22.2 → 1.23.0-alpha.1

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-memory
 description: Documentation for @mastra/memory. Use when working with @mastra/memory APIs, configuration, or implementation.
 metadata:
   package: "@mastra/memory"
-  version: "1.22.2"
+  version: "1.23.0-alpha.1"
 ---
 
 ## When to use
@@ -21,15 +21,15 @@ Read the individual reference documents for detailed explanations and code examp
 - [Supervisor agents](references/docs-agents-supervisor-agents.md) - Learn how to coordinate multiple agents with delegation hooks, iteration monitoring, message filtering, and task completion scoring.
 - [Evals with memory](references/docs-evals-evals-with-memory.md) - Run scorers against memory-enabled agents — including observational memory in thread scope — using runEvals and dataset experiments.
 - [Background tasks](references/docs-long-running-agents-background-tasks.md) - Learn how to dispatch long-running tool calls in the background, keep the stream open until they complete, and orchestrate subagents asynchronously.
-- [Goals](references/docs-long-running-agents-goals.md) - Learn how to set a durable objective on an agent that is judged in the execution loop, so the agent keeps working until the goal is complete or the run budget is exhausted.
+- [Goals](references/docs-long-running-agents-goals.md) - Learn how to set a durable objective on an agent that's judged in the execution loop, so the agent keeps working until the goal is complete or the run budget is exhausted.
 - [Memory processors](references/docs-memory-memory-processors.md) - Learn how to use memory processors in Mastra to filter, trim, and transform messages before they're sent to the language model to manage context window limits.
 - [Message history](references/docs-memory-message-history.md) - Learn how to configure message history in Mastra to store recent messages from the current conversation.
 - [Multi-user threads](references/docs-memory-multi-user-threads.md) - Share one Mastra thread between multiple users by carrying speaker identity in the message body.
 - [Observational Memory](references/docs-memory-observational-memory.md) - Learn how Observational Memory keeps your agent's context window small while preserving long-term memory across conversations.
 - [Memory overview](references/docs-memory-overview.md) - Learn how Mastra's memory system works with working memory, message history, semantic recall, and observational memory.
 - [Semantic recall](references/docs-memory-semantic-recall.md) - Learn how to use semantic recall in Mastra to retrieve relevant messages from past conversations using vector search and embeddings.
-- [Storage](references/docs-memory-storage.md) - Configure storage for Mastra to persist conversations and other runtime state.
 - [Working memory](references/docs-memory-working-memory.md) - Learn how to configure working memory in Mastra to store persistent user data, preferences.
+- [Storage overview](references/docs-storage-overview.md) - Configure storage for Mastra to persist runtime state across agents, workflows, observability, evals, schedules, and memory.
 
 ### Reference
 
@@ -42,6 +42,8 @@ Read the individual reference documents for detailed explanations and code examp
 - [Reference: Memory.listThreads()](references/reference-memory-listThreads.md) - Documentation for the `Memory.listThreads()` method in Mastra, which retrieves threads with optional filtering by resourceId and/or metadata.
 - [Reference: Memory class](references/reference-memory-memory-class.md) - Documentation for the `Memory` class in Mastra, which provides a robust system for managing conversation history and thread-based message storage.
 - [Reference: Observational Memory](references/reference-memory-observational-memory.md) - API reference for Observational Memory in Mastra — a three-tier memory system that uses Observer and Reflector agents to maintain long-term memory across conversations.
+- [Reference: summarizeConversation()](references/reference-memory-summarizeConversation.md) - Documentation for the standalone `summarizeConversation()` function in Mastra, which summarizes messages you pass in and extracts structured values from them.
+- [Reference: Memory.summarizeThread()](references/reference-memory-summarizeThread.md) - Documentation for the `Memory.summarizeThread()` method in Mastra, which summarizes a thread's conversation in one shot and extracts structured values from it.
 - [Reference: TokenLimiterProcessor](references/reference-processors-token-limiter-processor.md) - Documentation for the TokenLimiterProcessor in Mastra, which limits the number of tokens in messages.
 - [Reference: Aurora DSQL Storage](references/reference-storage-dsql.md) - Documentation for the Amazon Aurora DSQL storage implementation in Mastra.
 - [Reference: DynamoDB storage](references/reference-storage-dynamodb.md) - Documentation for the DynamoDB storage implementation in Mastra, using a single-table design with ElectroDB.

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,129 +1,133 @@
 {
-  "version": "1.22.2",
+  "version": "1.23.0-alpha.1",
   "package": "@mastra/memory",
   "exports": {
     "Extractor": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 316
     },
     "ModelByInputTokens": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 1354
     },
     "OBSERVER_SYSTEM_PROMPT": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js"
+      "implementation": "dist/chunk-HF2E2T6Z.js"
     },
     "ObservationalMemory": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 27533
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 27685
     },
     "ObservationalMemoryProcessor": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 30164
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 30316
     },
     "TokenCounter": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 26858
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 21467
     },
     "WorkingMemoryExtractor": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 20684
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 22134
     },
     "buildObserverPrompt": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 4465
     },
     "buildObserverSystemPrompt": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 3732
     },
     "combineObservationGroupRanges": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 1446
     },
     "deriveObservationGroupProvenance": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 1480
     },
     "extractCurrentTask": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 4588
     },
     "formatMessagesForObserver": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 4187
     },
     "getObservationsAsOf": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 30386
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 30538
     },
     "hasCurrentTaskSection": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 4576
     },
     "injectAnchorIds": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 3287
     },
     "optimizeObservationsForContext": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 4599
     },
     "parseAnchorId": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 3260
     },
     "parseObservationGroups": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 1415
     },
     "parseObserverOutput": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 4479
     },
     "reconcileObservationGroupsFromReflection": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 1504
     },
     "renderObservationGroupsForReflection": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 1460
     },
     "stripEphemeralAnchorIds": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 3317
     },
     "stripObservationGroups": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 1437
     },
+    "summarizeConversation": {
+      "types": "dist/processors/index.d.ts",
+      "implementation": "dist/chunk-HF2E2T6Z.js"
+    },
     "wrapInObservationGroup": {
       "types": "dist/processors/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
+      "implementation": "dist/chunk-HF2E2T6Z.js",
       "line": 1408
     },
     "OBSERVATIONAL_MEMORY_DEFAULTS": {
@@ -144,40 +148,44 @@
     },
     "Memory": {
       "types": "dist/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 22109
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 23559
     },
     "MessageHistory": {
       "types": "dist/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js"
+      "implementation": "dist/chunk-HF2E2T6Z.js"
+    },
+    "SUMMARIZE_THREAD_DEFAULTS": {
+      "types": "dist/index.d.ts",
+      "implementation": "dist/chunk-HF2E2T6Z.js"
     },
     "SemanticRecall": {
       "types": "dist/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js"
+      "implementation": "dist/chunk-HF2E2T6Z.js"
     },
     "WorkingMemory": {
       "types": "dist/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js"
+      "implementation": "dist/chunk-HF2E2T6Z.js"
     },
     "deepMergeWorkingMemory": {
       "types": "dist/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 21748
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 23198
     },
     "extractWorkingMemoryContent": {
       "types": "dist/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 22064
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 23514
     },
     "extractWorkingMemoryTags": {
       "types": "dist/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 22032
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 23482
     },
     "removeWorkingMemoryTags": {
       "types": "dist/index.d.ts",
-      "implementation": "dist/chunk-TB6SV7QK.js",
-      "line": 22045
+      "implementation": "dist/chunk-HF2E2T6Z.js",
+      "line": 23495
     },
     "WORKING_MEMORY_STATE_ID": {
       "types": "dist/index.d.ts",
@@ -197,7 +205,7 @@
     "processors": {
       "index": "dist/processors/index.js",
       "chunks": [
-        "chunk-TB6SV7QK.js",
+        "chunk-HF2E2T6Z.js",
         "chunk-LSJJAJAF.js"
       ]
     }

package/dist/docs/references/docs-agents-agent-approval.md

@@ -48,7 +48,7 @@ for await (const chunk of stream.fullStream) {
 }
 ```
 
-> **Note:** Agent approval uses snapshots to capture request state. Configure a [storage provider](https://mastra.ai/docs/memory/storage) on your Mastra instance or you'll see a "snapshot not found" error.
+> **Note:** Agent approval uses snapshots to capture request state. Configure a [storage provider](https://mastra.ai/docs/storage/overview) on your Mastra instance or you'll see a "snapshot not found" error.
 >
 > Snapshots for agent runs are minimal resume artifacts: they hold only what's needed to resume the suspended run and are deleted once the run finishes. Use [tracing](https://mastra.ai/docs/observability/overview) for the execution record and [memory](https://mastra.ai/docs/memory/overview) for the conversation history.
 
@@ -420,7 +420,7 @@ Each returned run includes the suspended tool calls (`toolCallId`, `toolName`, `
 
 The same discovery is available over HTTP as `GET /agents/:agentId/suspended-runs` and in the client SDK as [`agent.listSuspendedRuns()`](https://mastra.ai/reference/client-js/agents), so browser-based approval UIs can rediscover pending runs directly.
 
-> **Note:** Suspended runs only survive restarts when your Mastra instance is configured with a persistent [storage provider](https://mastra.ai/docs/memory/storage). The default in-memory store loses snapshots when the process exits.
+> **Note:** Suspended runs only survive restarts when your Mastra instance is configured with a persistent [storage provider](https://mastra.ai/docs/storage/overview). The default in-memory store loses snapshots when the process exits.
 
 ## Tool approval: Supervisor agents
 

package/dist/docs/references/docs-agents-networks.md

@@ -95,7 +95,7 @@ console.log(final?.summary)
 
 When a primitive requires approval, the stream emits an `agent-execution-approval` or `tool-execution-approval` chunk. Use `approveNetworkToolCall()` or `declineNetworkToolCall()` to respond.
 
-Network approval uses snapshots to capture execution state. Ensure a [storage provider](https://mastra.ai/docs/memory/storage) is enabled in your Mastra instance.
+Network approval uses snapshots to capture execution state. Ensure a [storage provider](https://mastra.ai/docs/storage/overview) is enabled in your Mastra instance.
 
 ```typescript
 const stream = await routingAgent.network('Perform some sensitive action', {

package/dist/docs/references/docs-long-running-agents-background-tasks.md

@@ -16,7 +16,7 @@ Use background tasks when a tool call may take long enough that the user shouldn
 
 For tool calls that return quickly, foreground execution using `agent.stream()` and `agent.generate()` is simpler.
 
-> **Note:** Background tasks require a configured [storage](https://mastra.ai/docs/memory/storage) backend on the Mastra instance. Tasks are persisted so they survive process restarts.
+> **Note:** Background tasks require a configured [storage](https://mastra.ai/docs/storage/overview) backend on the Mastra instance. Tasks are persisted so they survive process restarts.
 
 ## Quickstart
 
@@ -379,4 +379,4 @@ These read from storage rather than the pubsub stream, so they're suitable for p
 - [Durable agents](https://mastra.ai/docs/long-running-agents/durable-agents)
 - [Supervisor agents](https://mastra.ai/docs/agents/supervisor-agents)
 - [Stream chunk types](https://mastra.ai/reference/streaming/ChunkType)
-- [Storage](https://mastra.ai/docs/memory/storage)
+- [Storage](https://mastra.ai/docs/storage/overview)

package/dist/docs/references/docs-long-running-agents-goals.md

@@ -6,7 +6,7 @@
 
 > **Beta:** The Goals feature is in beta stage and subject to breaking changes in minor versions until it graduates from its beta status.
 
-A goal is a durable, thread-scoped objective: a standing instruction the agent keeps working toward across loop iterations until a judge model decides it is satisfied or a run budget is exhausted. The objective is persisted in thread state, so it survives reloads and is evaluated in-loop — even when a new message arrives in the middle of an already-running turn.
+A goal is a durable, thread-scoped objective: a standing instruction the agent keeps working toward across loop iterations until a judge model decides it's satisfied or a run budget is exhausted. The objective is persisted in thread state, so it survives reloads and is evaluated in-loop — even when a new message arrives in the middle of an already-running turn.
 
 Goals build on the same machinery as [`isTaskComplete`](https://mastra.ai/docs/agents/supervisor-agents): an LLM-as-judge scores the agent's output each iteration and gates the loop. The difference is that a goal is **durable** (stored in thread state, not passed per call) and is set and updated through `Agent` methods rather than per-`stream()` options.
 
@@ -22,7 +22,7 @@ For a one-off completion check within a single `stream()` call, use [`isTaskComp
 
 ## Quickstart
 
-Goals require a configured [storage](https://mastra.ai/docs/memory/storage) backend and a memory-backed thread. Add a `goal` config to the agent — a judge model is required for the goal to do anything — then set an objective for a thread:
+Goals require a configured [storage](https://mastra.ai/docs/storage/overview) backend and a memory-backed thread. Add a `goal` config to the agent — a judge model is required for the goal to do anything — then set an objective for a thread:
 
 ```typescript
 import { Agent } from '@mastra/core/agent'
@@ -89,7 +89,7 @@ Each evaluation emits a typed `goal` stream chunk (`GoalEvaluationPayload`: `obj
 
 ## Managing the objective
 
-Control the objective for a thread with `Agent` methods. All of them no-op when the run is not memory-backed (they require storage and a `threadId`):
+Control the objective for a thread with `Agent` methods. All of them no-op when the run isn't memory-backed (they require storage and a `threadId`):
 
 ```typescript
 // Read the current objective record.
@@ -111,4 +111,4 @@ Per-objective values written by `setObjective` / `updateObjectiveOptions` take p
 
 - [Supervisor agents](https://mastra.ai/docs/agents/supervisor-agents) — `isTaskComplete` and the rubric scorer
 - [Signal providers](https://mastra.ai/docs/long-running-agents/signal-providers) — how the objective is projected into context
-- [Memory storage](https://mastra.ai/docs/memory/storage) — the storage backend goals require
+- [Memory storage](https://mastra.ai/docs/storage/overview) — the storage backend goals require

package/dist/docs/references/docs-memory-memory-processors.md

@@ -309,6 +309,73 @@ const agent = new Agent({
 
 Both scenarios are safe - guardrails prevent inappropriate content from being persisted to memory
 
+## Handling large attachments
+
+Some storage providers enforce record size limits that base64-encoded file attachments can exceed:
+
+| Provider                                                           | Record size limit |
+| ------------------------------------------------------------------ | ----------------- |
+| [DynamoDB](https://mastra.ai/reference/storage/dynamodb)           | 400 KB            |
+| [Convex](https://mastra.ai/reference/storage/convex)               | 1 MiB             |
+| [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1) | 1 MiB             |
+
+PostgreSQL, MongoDB, and libSQL have higher limits and are usually unaffected.
+
+Use an input processor to upload attachments to external storage, then replace them with URL references before messages are persisted.
+
+```typescript
+import type { Processor } from '@mastra/core/processors'
+import type { MastraDBMessage } from '@mastra/core/memory'
+
+export class AttachmentUploader implements Processor {
+  id = 'attachment-uploader'
+
+  async processInput({ messages }: { messages: MastraDBMessage[] }) {
+    return Promise.all(messages.map(message => this.processMessage(message)))
+  }
+
+  async processMessage(message: MastraDBMessage) {
+    const attachments = message.content.experimental_attachments
+    if (!attachments?.length) return message
+
+    const uploaded = await Promise.all(
+      attachments.map(async attachment => {
+        if (!attachment.url?.startsWith('data:')) return attachment
+
+        const url = await this.upload(attachment.url, attachment.contentType)
+        return { ...attachment, url }
+      }),
+    )
+
+    return { ...message, content: { ...message.content, experimental_attachments: uploaded } }
+  }
+
+  async upload(dataUri: string, contentType?: string): Promise<string> {
+    const base64 = dataUri.split(',')[1]
+    const buffer = Buffer.from(base64, 'base64')
+
+    throw new Error('Implement upload() with your storage provider')
+  }
+}
+```
+
+Use the processor with your agent:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+import { AttachmentUploader } from '../processors/attachment-uploader'
+
+export const supportAgent = new Agent({
+  id: 'support-agent',
+  name: 'Support agent',
+  instructions: 'Answer customer support questions.',
+  model: 'openai/gpt-5.5',
+  memory: new Memory({ lastMessages: 10 }),
+  inputProcessors: [new AttachmentUploader()],
+})
+```
+
 ## Related documentation
 
 - [Processors](https://mastra.ai/docs/agents/processors): General processor concepts and custom processor creation

package/dist/docs/references/docs-memory-message-history.md

@@ -6,7 +6,7 @@ Message history is the most basic and important form of memory. It gives the LLM
 
 You can also retrieve message history to display past conversations in your UI.
 
-> **Info:** Each message belongs to a thread (the conversation) and a resource (the user or entity it's associated with). See [Threads and resources](https://mastra.ai/docs/memory/storage) for more detail.
+> **Info:** Each message belongs to a thread (the conversation) and a resource (the user or entity it's associated with). See [Threads and resources](#threads-and-resources) for more detail.
 
 > **Warning:** When you use memory with a client application, send **only the new message** from the client instead of the full conversation history.
 >
@@ -14,9 +14,18 @@ You can also retrieve message history to display past conversations in your UI.
 >
 > For an AI SDK example, see [Using Mastra Memory](https://mastra.ai/guides/build-your-ui/ai-sdk-ui).
 
+## Threads and resources
+
+Mastra organizes conversations using two identifiers:
+
+- **Thread**: A conversation session containing a sequence of messages.
+- **Resource**: The entity that owns the thread, such as a user, organization, project, or another domain entity in your application.
+
+Studio automatically generates a thread and resource ID for you. When calling `stream()` or `generate()` yourself, provide these identifiers explicitly.
+
 ## Getting started
 
-Install the Mastra memory module along with a [storage adapter](https://mastra.ai/docs/memory/storage) for your database. The examples below use `@mastra/libsql`, which stores data locally in a `mastra.db` file.
+Install the Mastra memory module along with a [storage adapter](https://mastra.ai/docs/storage/overview) for your database. The examples below use `@mastra/libsql`, which stores data locally in a `mastra.db` file.
 
 **npm**:
 
@@ -113,6 +122,51 @@ You can use this history in two ways:
 
 > **Tip:** When memory is enabled, [Studio](https://mastra.ai/docs/studio/overview) uses message history to display past conversations in the chat sidebar.
 
+## Thread title generation
+
+Mastra can automatically generate descriptive thread titles based on the user's first message when `generateTitle` is enabled. Use this option when you build a chat interface that renders conversation titles in a thread list or sidebar.
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+
+export const supportAgent = new Agent({
+  id: 'support-agent',
+  name: 'Support agent',
+  instructions: 'Answer customer support questions.',
+  model: 'openai/gpt-5.5',
+  memory: new Memory({
+    options: {
+      generateTitle: true,
+    },
+  }),
+})
+```
+
+Title generation runs asynchronously after the agent responds and doesn't affect response time.
+
+To optimize cost or behavior, provide a smaller [`model`](https://mastra.ai/models) and custom `instructions`:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+
+export const supportAgent = new Agent({
+  id: 'support-agent',
+  name: 'Support agent',
+  instructions: 'Answer customer support questions.',
+  model: 'openai/gpt-5.5',
+  memory: new Memory({
+    options: {
+      generateTitle: {
+        model: 'openai/gpt-5-mini',
+        instructions: 'Generate a one-word title.',
+      },
+    },
+  }),
+})
+```
+
 ## Accessing memory
 
 To access memory functions for querying, cloning, or deleting threads and messages, call `getMemory()` on an agent:

package/dist/docs/references/docs-memory-observational-memory.md

@@ -217,7 +217,7 @@ new Extractor({
 })
 ```
 
-By default, OM shows the last extracted value to the extractor on later runs. Set `includePreviousExtraction: false` when the Observer should not see the previous value.
+By default, OM shows the last extracted value to the extractor on later runs. Set `includePreviousExtraction: false` when the Observer shouldn't see the previous value.
 
 ```typescript
 new Extractor({
@@ -263,7 +263,7 @@ const memory = new Memory({
 
 This setting adds `WorkingMemoryExtractor`, defaults `workingMemory.agentManaged` to `false`, and defaults `workingMemory.useStateSignals` to `true`. Set `workingMemory.agentManaged: true` if the main agent should still receive working memory tool and instruction injection.
 
-Use `onExtracted` to normalize or react to custom extracted values before they are persisted:
+Use `onExtracted` to normalize or react to custom extracted values before they're persisted:
 
 ```typescript
 new Extractor({
@@ -280,7 +280,7 @@ new Extractor({
 })
 ```
 
-Extractor failures are reported in OM markers and do not block other successful extractor values. See [the API reference](https://mastra.ai/reference/memory/observational-memory) for the full `Extractor` shape.
+Extractor failures are reported in OM markers and don't block other successful extractor values. See [the API reference](https://mastra.ai/reference/memory/observational-memory) for the full `Extractor` shape.
 
 If your Observer model is text-only or its API rejects multimodal input, set `observation.observeAttachments` to `false` to drop attachments before they reach the Observer. The readable placeholders (`[Image #1: ...]`, `[File #1: ...]`) are kept in the transcript so the Observer can still reason about what was shared without receiving the binary payload. The same filter applies to tool results that contain image or file parts:
 

package/dist/docs/references/docs-memory-overview.md

@@ -13,7 +13,7 @@ Mastra agents can be configured to store [message history](https://mastra.ai/doc
 
 If the combined memory exceeds the model's context limit, [memory processors](https://mastra.ai/docs/memory/memory-processors) can filter, trim, or prioritize content so the most relevant information is preserved.
 
-Memory results will be stored in one or more of your configured [storage providers](https://mastra.ai/docs/memory/storage).
+Memory results will be stored in one or more of your configured [storage providers](https://mastra.ai/docs/storage/overview).
 
 ## When to use memory
 
@@ -75,7 +75,7 @@ Use memory when your agent needs to maintain multi-turn conversations that refer
    bun add @mastra/libsql@latest
    ```
 
-   > **Note:** For more details on available providers and how storage works in Mastra, visit the [storage](https://mastra.ai/docs/memory/storage) documentation.
+   > **Note:** For more details on available providers and how storage works in Mastra, visit the [storage](https://mastra.ai/docs/storage/overview) documentation.
 
 3. Add the storage provider to your main Mastra instance to enable memory across all configured agents.
 
@@ -178,7 +178,7 @@ Each delegation creates a fresh `threadId` and a deterministic `resourceId` for
 - **Resource ID**: Derived as `{parentResourceId}-{agentName}`. Because the resource ID is stable across delegations, resource-scoped memory persists between calls. A subagent remembers facts from previous delegations by the same user.
 - **Memory instance**: If a subagent has no memory configured, it inherits the supervisor's `Memory` instance, including all of its options. If the subagent defines its own, that takes precedence.
 
-> **Note:** Title generation (`generateTitle`) is a top-level thread concern and is **not** applied to inherited subagent threads. Because each delegation creates an ephemeral thread that no one sees, running title generation for it would waste an LLM call per delegation. To generate titles for a subagent's own threads, give that subagent its own memory configuration.
+> **Note:** Title generation (`generateTitle`) is a top-level thread concern and **isn't** applied to inherited subagent threads. Because each delegation creates an ephemeral thread that no one sees, running title generation for it would waste an LLM call per delegation. To generate titles for a subagent's own threads, give that subagent its own memory configuration.
 
 The supervisor forwards its conversation context to the subagent so it has enough background to complete the task. Only the delegation prompt and the subagent's response are saved — the full parent conversation isn't stored. You can control which messages reach the subagent with the [`messageFilter`](https://mastra.ai/docs/agents/supervisor-agents) callback.
 

package/dist/docs/references/docs-memory-semantic-recall.md

@@ -22,6 +22,8 @@ After getting a response from the LLM, all new messages (user, assistant, and to
 
 Semantic recall is disabled by default. To enable it, set `semanticRecall: true` in `options` and provide a `vector` store and `embedder`:
 
+**LibSQL**:
+
 ```typescript
 import { Agent } from '@mastra/core/agent'
 import { Memory } from '@mastra/memory'
@@ -50,6 +52,38 @@ const agent = new Agent({
 })
 ```
 
+**MongoDB**:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { Memory } from '@mastra/memory'
+import { MongoDBStore, MongoDBVector } from '@mastra/mongodb'
+import { ModelRouterEmbeddingModel } from '@mastra/core/llm'
+
+const agent = new Agent({
+  id: 'support-agent',
+  name: 'SupportAgent',
+  instructions: 'You are a helpful support agent.',
+  model: 'openai/gpt-5.5',
+  memory: new Memory({
+    storage: new MongoDBStore({
+      id: 'agent-storage',
+      uri: process.env.MONGODB_URI,
+      dbName: process.env.MONGODB_DB_NAME,
+    }),
+    vector: new MongoDBVector({
+      id: 'agent-vector',
+      uri: process.env.MONGODB_URI,
+      dbName: process.env.MONGODB_DB_NAME,
+    }),
+    embedder: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'),
+    options: {
+      semanticRecall: true,
+    },
+  }),
+})
+```
+
 ## Using the `recall()` method
 
 While `listMessages` retrieves messages by thread ID with basic pagination, [`recall()`](https://mastra.ai/reference/memory/recall) adds support for **semantic search**. When you need to find messages by meaning rather than recency, use `recall()` with a `vectorSearchString`:
@@ -146,7 +180,7 @@ const agent = new Agent({
 })
 ```
 
-> **Note:** `scope: 'resource'` is supported by the LibSQL, PostgreSQL, and Upstash storage adapters.
+> **Note:** `scope: 'resource'` is supported by the LibSQL, PostgreSQL, MongoDB, and Upstash storage adapters.
 
 ### Metadata filtering