@mastra/libsql 1.2.0 → 1.3.0-alpha.0

package/dist/docs/{observability/02-default.md → references/docs-observability-tracing-exporters-default.md}

@@ -1,11 +1,8 @@
-> Store traces locally for development and debugging
-
 # Default Exporter
 
 The `DefaultExporter` persists traces to your configured storage backend, making them accessible through Studio. It's automatically enabled when using the default observability configuration and requires no external services.
 
-> **Production Observability**
-Observability data can quickly overwhelm general-purpose databases in production. For high-traffic applications, we recommend using **ClickHouse** for the observability storage domain via [composite storage](https://mastra.ai/reference/storage/composite). See [Production Recommendations](#production-recommendations) for details.
+> **Production Observability:** Observability data can quickly overwhelm general-purpose databases in production. For high-traffic applications, we recommend using **ClickHouse** for the observability storage domain via [composite storage](https://mastra.ai/reference/storage/composite). See [Production Recommendations](#production-recommendations) for details.
 
 ## Configuration
 
@@ -16,7 +13,7 @@ Observability data can quickly overwhelm general-purpose databases in production
 
 ### Basic Setup
 
-```typescript title="src/mastra/index.ts"
+```typescript
 import { Mastra } from "@mastra/core";
 import { Observability, DefaultExporter } from "@mastra/observability";
 import { LibSQLStore } from "@mastra/libsql";
@@ -119,13 +116,13 @@ If you set the strategy to `'auto'`, the `DefaultExporter` automatically selects
 
 ### Providers with Observability Support
 
-| Storage Provider                                | Preferred Strategy | Supported Strategies                      | Recommended Use                       |
-| ----------------------------------------------- | ------------------ | ----------------------------------------- | ------------------------------------- |
-| **ClickHouse** (`@mastra/clickhouse`)           | insert-only        | insert-only                               | Production (high-volume)              |
-| **[PostgreSQL](https://mastra.ai/reference/storage/postgresql)** | batch-with-updates | batch-with-updates, insert-only           | Production (low volume)               |
-| **[MSSQL](https://mastra.ai/reference/storage/mssql)**           | batch-with-updates | batch-with-updates, insert-only           | Production (low volume)               |
-| **[MongoDB](https://mastra.ai/reference/storage/mongodb)**       | batch-with-updates | batch-with-updates, insert-only           | Production (low volume)               |
-| **[libSQL](https://mastra.ai/reference/storage/libsql)**         | batch-with-updates | batch-with-updates, insert-only           | Default storage, good for development |
+| Storage Provider                                                 | Preferred Strategy | Supported Strategies            | Recommended Use                       |
+| ---------------------------------------------------------------- | ------------------ | ------------------------------- | ------------------------------------- |
+| **ClickHouse** (`@mastra/clickhouse`)                            | insert-only        | insert-only                     | Production (high-volume)              |
+| **[PostgreSQL](https://mastra.ai/reference/storage/postgresql)** | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
+| **[MSSQL](https://mastra.ai/reference/storage/mssql)**           | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
+| **[MongoDB](https://mastra.ai/reference/storage/mongodb)**       | batch-with-updates | batch-with-updates, insert-only | Production (low volume)               |
+| **[libSQL](https://mastra.ai/reference/storage/libsql)**         | batch-with-updates | batch-with-updates, insert-only | Default storage, good for development |
 
 ### Providers without Observability Support
 
@@ -150,7 +147,7 @@ Observability data grows quickly in production environments. A single agent inte
 
 ### Recommended: ClickHouse for High-Volume Production
 
-[ClickHouse](https://mastra.ai/reference/storage/composite#specialized-storage-for-observability) is a columnar database designed for high-volume analytics workloads. It's the recommended choice for production observability because:
+[ClickHouse](https://mastra.ai/reference/storage/composite) is a columnar database designed for high-volume analytics workloads. It's the recommended choice for production observability because:
 
 - **Optimized for writes**: Handles millions of inserts per second
 - **Efficient compression**: Reduces storage costs for trace data
@@ -159,7 +156,7 @@ Observability data grows quickly in production environments. A single agent inte
 
 ### Using Composite Storage
 
-If you're using a provider without observability support (like Convex or DynamoDB) or want to optimize performance, use [composite storage](https://mastra.ai/reference/storage/composite#specialized-storage-for-observability) to route observability data to ClickHouse while keeping other data in your primary database.
+If you're using a provider without observability support (like Convex or DynamoDB) or want to optimize performance, use [composite storage](https://mastra.ai/reference/storage/composite) to route observability data to ClickHouse while keeping other data in your primary database.
 
 ## Batching Behavior
 

package/dist/docs/{rag/01-retrieval.md → references/docs-rag-retrieval.md}

@@ -1,5 +1,3 @@
-> Guide on retrieval processes in Mastra
-
 # Retrieval in RAG Systems
 
 After storing embeddings, you need to retrieve relevant chunks to answer user queries.
@@ -168,10 +166,9 @@ This is particularly useful when:
 
 The Vector Query Tool supports database-specific configurations that enable you to leverage unique features and optimizations of different vector stores.
 
-> **Note:**
-These configurations are for **query-time options** like namespaces, performance tuning, and filtering—not for database connection setup. 
-
-Connection credentials (URLs, auth tokens) are configured when you instantiate the vector store class (e.g., `new LibSQLVector({ url: '...' })`).
+> **Note:** These configurations are for **query-time options** like namespaces, performance tuning, and filtering—not for database connection setup.
+>
+> Connection credentials (URLs, auth tokens) are configured when you instantiate the vector store class (e.g., `new LibSQLVector({ url: '...' })`).
 
 ```ts
 import { createVectorQueryTool } from "@mastra/rag";
@@ -268,10 +265,9 @@ For detailed configuration options and advanced usage, see the [Vector Query Too
 
 ### Vector Store Prompts
 
-Vector store prompts define query patterns and filtering capabilities for each vector database implementation.
-When implementing filtering, these prompts are required in the agent's instructions to specify valid operators and syntax for each vector store implementation.
+Vector store prompts define query patterns and filtering capabilities for each vector database implementation. When implementing filtering, these prompts are required in the agent's instructions to specify valid operators and syntax for each vector store implementation.
 
-  **pgvector:**
+**pgVector**:
 
 ```ts
 import { PGVECTOR_PROMPT } from "@mastra/pg";
@@ -288,11 +284,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
-
-  **pinecone:**
+**Pinecone**:
 
-```ts title="vector-store.ts"
+```ts
 import { PINECONE_PROMPT } from "@mastra/pinecone";
 
 export const ragAgent = new Agent({
@@ -307,11 +301,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
-
-  **qdrant:**
+**Qdrant**:
 
-```ts title="vector-store.ts"
+```ts
 import { QDRANT_PROMPT } from "@mastra/qdrant";
 
 export const ragAgent = new Agent({
@@ -326,11 +318,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
+**Chroma**:
 
-  **chroma:**
-
-```ts title="vector-store.ts"
+```ts
 import { CHROMA_PROMPT } from "@mastra/chroma";
 
 export const ragAgent = new Agent({
@@ -345,11 +335,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
-
-  **astra:**
+**Astra**:
 
-```ts title="vector-store.ts"
+```ts
 import { ASTRA_PROMPT } from "@mastra/astra";
 
 export const ragAgent = new Agent({
@@ -364,11 +352,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
-
-  **libsql:**
+**libSQL**:
 
-```ts title="vector-store.ts"
+```ts
 import { LIBSQL_PROMPT } from "@mastra/libsql";
 
 export const ragAgent = new Agent({
@@ -383,11 +369,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
+**Upstash**:
 
-  **upstash:**
-
-```ts title="vector-store.ts"
+```ts
 import { UPSTASH_PROMPT } from "@mastra/upstash";
 
 export const ragAgent = new Agent({
@@ -402,11 +386,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
-
-  **vectorize:**
+**Vectorize**:
 
-```ts title="vector-store.ts"
+```ts
 import { VECTORIZE_PROMPT } from "@mastra/vectorize";
 
 export const ragAgent = new Agent({
@@ -421,11 +403,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
-
-  **mongodb:**
+**MongoDB**:
 
-```ts title="vector-store.ts"
+```ts
 import { MONGODB_PROMPT } from "@mastra/mongodb";
 
 export const ragAgent = new Agent({
@@ -440,11 +420,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
+**OpenSearch**:
 
-  **opensearch:**
-
-```ts title="vector-store.ts"
+```ts
 import { OPENSEARCH_PROMPT } from "@mastra/opensearch";
 
 export const ragAgent = new Agent({
@@ -459,11 +437,9 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
-
-  **s3vectors:**
+**S3Vectors**:
 
-```ts title="vector-store.ts"
+```ts
 import { S3VECTORS_PROMPT } from "@mastra/s3vectors";
 
 export const ragAgent = new Agent({
@@ -478,8 +454,6 @@ export const ragAgent = new Agent({
 });
 ```
 
-  
-
 ### Re-ranking
 
 Initial vector similarity search can sometimes miss nuanced relevance. Re-ranking is a more computationally expensive process, but more accurate algorithm that improves results by:
@@ -528,8 +502,7 @@ The weights control how different factors influence the final ranking:
 - `vector`: Higher values favor the original vector similarity scores
 - `position`: Higher values help maintain the original ordering of results
 
-> **Note:**
-For semantic scoring to work properly during re-ranking, each result must include the text content in its `metadata.text` field.
+> **Note:** For semantic scoring to work properly during re-ranking, each result must include the text content in its `metadata.text` field.
 
 You can also use other relevance score providers like Cohere or ZeroEntropy:
 

package/dist/docs/{workflows/01-snapshots.md → references/docs-workflows-snapshots.md}

@@ -1,5 +1,3 @@
-> Learn how to save and resume workflow execution state with snapshots in Mastra
-
 # Snapshots
 
 In Mastra, a snapshot is a serializable representation of a workflow's complete execution state at a specific point in time. Snapshots capture all the information needed to resume a workflow from exactly where it left off, including:
@@ -125,7 +123,7 @@ console.log(snapshot);
 
 Snapshots are persisted using a `storage` instance configured on the `Mastra` class. This storage layer is shared across all workflows registered to that instance. Mastra supports multiple storage options for flexibility in different environments.
 
-```typescript title="src/mastra/index.ts" 
+```typescript
 import { Mastra } from "@mastra/core";
 import { LibSQLStore } from "@mastra/libsql";
 import { approvalWorkflow } from "./workflows";
@@ -159,7 +157,7 @@ export const mastra = new Mastra({
 
 You can attach custom metadata when suspending a workflow by defining a `suspendSchema`. This metadata is stored in the snapshot and made available when the workflow is resumed.
 
-```typescript {30-34} title="src/mastra/workflows/test-workflow.ts"
+```typescript
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
@@ -208,7 +206,7 @@ const approvalStep = createStep({
 
 Use `resumeData` to pass structured input when resuming a suspended step. It must match the step’s `resumeSchema`.
 
-```typescript {14-20}
+```typescript
 const workflow = mastra.getWorkflow("approvalWorkflow");
 
 const run = await workflow.createRun();

package/dist/docs/{guides/01-ai-sdk.md → references/guides-agent-frameworks-ai-sdk.md}

@@ -1,28 +1,44 @@
-> Use Mastra processors and memory with the Vercel AI SDK
-
 # AI SDK
 
 If you're already using the [Vercel AI SDK](https://sdk.vercel.ai) directly and want to add Mastra capabilities like [processors](https://mastra.ai/docs/agents/processors) or [memory](https://mastra.ai/docs/memory/memory-processors) without switching to the full Mastra agent API, [`withMastra()`](https://mastra.ai/reference/ai-sdk/with-mastra) lets you wrap any AI SDK model with these features. This is useful when you want to keep your existing AI SDK code but add input/output processing, conversation persistence, or content filtering.
 
-> **Note:**
-
-If you want to use Mastra together with AI SDK UI (e.g. `useChat()`), visit the [AI SDK UI guide](https://mastra.ai/guides/build-your-ui/ai-sdk-ui).
+> **Tip:** If you want to use Mastra together with AI SDK UI (e.g. `useChat()`), visit the [AI SDK UI guide](https://mastra.ai/guides/build-your-ui/ai-sdk-ui).
 
 ## Installation
 
 Install `@mastra/ai-sdk` to begin using the `withMastra()` function.
 
-```bash npm2yarn
+**npm**:
+
+```bash
 npm install @mastra/ai-sdk@latest
 ```
 
+**pnpm**:
+
+```bash
+pnpm add @mastra/ai-sdk@latest
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/ai-sdk@latest
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/ai-sdk@latest
+```
+
 ## Examples
 
 ### With Processors
 
 Processors let you transform messages before they're sent to the model (`processInput`) and after responses are received (`processOutputResult`). This example creates a logging processor that logs message counts at each stage, then wraps an OpenAI model with it.
 
-```typescript title="src/example.ts"
+```typescript
 import { openai } from '@ai-sdk/openai';
 import { generateText } from 'ai';
 import { withMastra } from '@mastra/ai-sdk';
@@ -55,7 +71,7 @@ const { text } = await generateText({
 
 Memory automatically loads previous messages from storage before the LLM call and saves new messages after. This example configures a libSQL storage backend to persist conversation history, loading the last 10 messages for context.
 
-```typescript title="src/memory-example.ts"
+```typescript
 import { openai } from '@ai-sdk/openai';
 import { generateText } from 'ai';
 import { withMastra } from '@mastra/ai-sdk';
@@ -86,7 +102,7 @@ const { text } = await generateText({
 
 You can combine processors and memory together. Input processors run after memory loads historical messages, and output processors run before memory saves the response.
 
-```typescript title="src/combined-example.ts"
+```typescript
 import { openai } from '@ai-sdk/openai';
 import { generateText } from 'ai';
 import { withMastra } from '@mastra/ai-sdk';

package/dist/docs/references/reference-core-getMemory.md

@@ -0,0 +1,50 @@
+# Mastra.getMemory()
+
+The `.getMemory()` method retrieves a memory instance from the Mastra registry by its key. Memory instances are registered in the Mastra constructor and can be referenced by stored agents.
+
+## Usage example
+
+```typescript
+const memory = mastra.getMemory("conversationMemory");
+
+// Use the memory instance
+const thread = await memory.createThread({
+  resourceId: "user-123",
+  title: "New Conversation",
+});
+```
+
+## Parameters
+
+**key:** (`TMemoryKey extends keyof TMemory`): The registry key of the memory instance to retrieve. Must match a key used when registering memory in the Mastra constructor.
+
+## Returns
+
+**memory:** (`TMemory[TMemoryKey]`): The memory instance with the specified key. Throws an error if the memory is not found.
+
+## Example: Registering and Retrieving Memory
+
+```typescript
+import { Mastra } from "@mastra/core";
+import { Memory } from "@mastra/memory";
+import { LibSQLStore } from "@mastra/libsql";
+
+const conversationMemory = new Memory({
+  storage: new LibSQLStore({ id: 'conversation-store', url: ":memory:" }),
+});
+
+const mastra = new Mastra({
+  memory: {
+    conversationMemory,
+  },
+});
+
+// Later, retrieve the memory instance
+const memory = mastra.getMemory("conversationMemory");
+```
+
+## Related
+
+- [Mastra.listMemory()](https://mastra.ai/reference/core/listMemory)
+- [Memory overview](https://mastra.ai/docs/memory/overview)
+- [Agent Memory](https://mastra.ai/docs/agents/agent-memory)

package/dist/docs/references/reference-core-listMemory.md

@@ -0,0 +1,56 @@
+# Mastra.listMemory()
+
+The `.listMemory()` method returns all memory instances registered with the Mastra instance.
+
+## Usage example
+
+```typescript
+const memoryInstances = mastra.listMemory();
+
+for (const [key, memory] of Object.entries(memoryInstances)) {
+  console.log(`Memory "${key}": ${memory.id}`);
+}
+```
+
+## Parameters
+
+This method takes no parameters.
+
+## Returns
+
+**memory:** (`Record<string, MastraMemory>`): An object containing all registered memory instances, keyed by their registry keys.
+
+## Example: Checking Registered Memory
+
+```typescript
+import { Mastra } from "@mastra/core";
+import { Memory } from "@mastra/memory";
+import { LibSQLStore } from "@mastra/libsql";
+
+const conversationMemory = new Memory({
+  id: "conversation-memory",
+  storage: new LibSQLStore({ id: 'conversation-store', url: ":memory:" }),
+});
+
+const analyticsMemory = new Memory({
+  id: "analytics-memory",
+  storage: new LibSQLStore({ id: 'analytics-store', url: ":memory:" }),
+});
+
+const mastra = new Mastra({
+  memory: {
+    conversationMemory,
+    analyticsMemory,
+  },
+});
+
+// List all registered memory instances
+const allMemory = mastra.listMemory();
+console.log(Object.keys(allMemory)); // ["conversationMemory", "analyticsMemory"]
+```
+
+## Related
+
+- [Mastra.getMemory()](https://mastra.ai/reference/core/getMemory)
+- [Memory overview](https://mastra.ai/docs/memory/overview)
+- [Agent Memory](https://mastra.ai/docs/agents/agent-memory)

package/dist/docs/references/reference-core-mastra-class.md

@@ -0,0 +1,66 @@
+# Mastra Class
+
+The `Mastra` class is the central orchestrator in any Mastra application, managing agents, workflows, storage, logging, observability, and more. Typically, you create a single instance of `Mastra` to coordinate your application.
+
+Think of `Mastra` as a top-level registry where you register agents, workflows, tools, and other components that need to be accessible throughout your application.
+
+## Usage example
+
+```typescript
+import { Mastra } from "@mastra/core";
+import { PinoLogger } from "@mastra/loggers";
+import { LibSQLStore } from "@mastra/libsql";
+import { weatherWorkflow } from "./workflows/weather-workflow";
+import { weatherAgent } from "./agents/weather-agent";
+
+export const mastra = new Mastra({
+  workflows: { weatherWorkflow },
+  agents: { weatherAgent },
+  storage: new LibSQLStore({
+    id: 'mastra-storage',
+    url: ":memory:",
+  }),
+  logger: new PinoLogger({
+    name: "Mastra",
+    level: "info",
+  }),
+});
+```
+
+## Constructor parameters
+
+Visit the [Configuration reference](https://mastra.ai/reference/configuration) for detailed documentation on all available configuration options.
+
+**agents?:** (`Record<string, Agent>`): Agent instances to register, keyed by name (Default: `{}`)
+
+**tools?:** (`Record<string, ToolApi>`): Custom tools to register. Structured as a key-value pair, with keys being the tool name and values being the tool function. (Default: `{}`)
+
+**storage?:** (`MastraCompositeStore`): Storage engine instance for persisting data
+
+**vectors?:** (`Record<string, MastraVector>`): Vector store instance, used for semantic search and vector-based tools (eg Pinecone, PgVector or Qdrant)
+
+**logger?:** (`Logger`): Logger instance created with new PinoLogger() (Default: `Console logger with INFO level`)
+
+**idGenerator?:** (`() => string`): Custom ID generator function. Used by agents, workflows, memory, and other components to generate unique identifiers.
+
+**workflows?:** (`Record<string, Workflow>`): Workflows to register. Structured as a key-value pair, with keys being the workflow name and values being the workflow instance. (Default: `{}`)
+
+**tts?:** (`Record<string, MastraVoice>`): Text-to-speech providers for voice synthesis
+
+**observability?:** (`ObservabilityEntrypoint`): Observability configuration for tracing and monitoring
+
+**deployer?:** (`MastraDeployer`): An instance of a MastraDeployer for managing deployments.
+
+**server?:** (`ServerConfig`): Server configuration including port, host, timeout, API routes, middleware, CORS settings, and build options for Swagger UI, API request logging, and OpenAPI docs.
+
+**mcpServers?:** (`Record<string, MCPServerBase>`): An object where keys are registry keys (used for getMCPServer()) and values are instances of MCPServer or classes extending MCPServerBase. Each MCPServer must have an id property. Servers can be retrieved by registry key using getMCPServer() or by their intrinsic id using getMCPServerById().
+
+**bundler?:** (`BundlerConfig`): Configuration for the asset bundler with options for externals, sourcemap, and transpilePackages.
+
+**scorers?:** (`Record<string, Scorer>`): Scorers for evaluating agent responses and workflow outputs (Default: `{}`)
+
+**processors?:** (`Record<string, Processor>`): Input/output processors for transforming agent inputs and outputs (Default: `{}`)
+
+**gateways?:** (`Record<string, MastraModelGateway>`): Custom model gateways to register for accessing AI models through alternative providers or private deployments. Structured as a key-value pair, with keys being the registry key (used for getGateway()) and values being gateway instances. (Default: `{}`)
+
+**memory?:** (`Record<string, MastraMemory>`): Memory instances to register. These can be referenced by stored agents and resolved at runtime. Structured as a key-value pair, with keys being the registry key and values being memory instances. (Default: `{}`)

package/dist/docs/{memory/07-reference.md → references/reference-memory-memory-class.md}

@@ -1,19 +1,10 @@
-# Memory API Reference
-
-> API reference for memory - 1 entries
-
-
----
-
-## Reference: Memory Class
-
-> Documentation for the `Memory` class in Mastra, which provides a robust system for managing conversation history and thread-based message storage.
+# Memory Class
 
 The `Memory` class provides a robust system for managing conversation history and thread-based message storage in Mastra. It enables persistent storage of conversations, semantic search capabilities, and efficient message retrieval. You must configure a storage provider for conversation history, and if you enable semantic recall you will also need to provide a vector store and embedder.
 
 ## Usage example
 
-```typescript title="src/mastra/agents/test-agent.ts"
+```typescript
 import { Memory } from "@mastra/memory";
 import { Agent } from "@mastra/core/agent";
 
@@ -31,17 +22,39 @@ export const agent = new Agent({
 });
 ```
 
-> To enable `workingMemory` on an agent, you’ll need a storage provider configured on your main Mastra instance. See [Mastra class](../core/mastra-class) for more information.
+> To enable `workingMemory` on an agent, you’ll need a storage provider configured on your main Mastra instance. See [Mastra class](https://mastra.ai/reference/core/mastra-class) for more information.
 
 ## Constructor parameters
 
+**storage?:** (`MastraCompositeStore`): Storage implementation for persisting memory data. Defaults to \`new DefaultStorage({ config: { url: "file:memory.db" } })\` if not provided.
+
+**vector?:** (`MastraVector | false`): Vector store for semantic search capabilities. Set to \`false\` to disable vector operations.
+
+**embedder?:** (`EmbeddingModel<string> | EmbeddingModelV2<string>`): Embedder instance for vector embeddings. Required when semantic recall is enabled.
+
+**options?:** (`MemoryConfig`): Memory configuration options.
+
 ### Options parameters
 
+**lastMessages?:** (`number | false`): Number of most recent messages to retrieve. Set to false to disable. (Default: `10`)
+
+**readOnly?:** (`boolean`): When true, prevents memory from saving new messages and provides working memory as read-only context (without the updateWorkingMemory tool). Useful for read-only operations like previews, internal routing agents, or sub agents that should reference but not modify memory. (Default: `false`)
+
+**semanticRecall?:** (`boolean | { topK: number; messageRange: number | { before: number; after: number }; scope?: 'thread' | 'resource' }`): Enable semantic search in message history. Can be a boolean or an object with configuration options. When enabled, requires both vector store and embedder to be configured. Default topK is 4, default messageRange is {before: 1, after: 1}. (Default: `false`)
+
+**workingMemory?:** (`WorkingMemory`): Configuration for working memory feature. Can be \`{ enabled: boolean; template?: string; schema?: ZodObject\<any> | JSONSchema7; scope?: 'thread' | 'resource' }\` or \`{ enabled: boolean }\` to disable. (Default: `{ enabled: false, template: '# User Information\n- **First Name**:\n- **Last Name**:\n...' }`)
+
+**observationalMemory?:** (`boolean | ObservationalMemoryOptions`): Enable Observational Memory for long-context agentic memory. Set to \`true\` for defaults, or pass a config object to customize token budgets, models, and scope. See \[Observational Memory reference]\(/reference/memory/observational-memory) for configuration details. (Default: `false`)
+
+**generateTitle?:** (`boolean | { model: DynamicArgument<MastraLanguageModel>; instructions?: DynamicArgument<string> }`): Controls automatic thread title generation from the user's first message. Can be a boolean or an object with custom model and instructions. (Default: `false`)
+
 ## Returns
 
+**memory:** (`Memory`): A new Memory instance with the specified configuration.
+
 ## Extended usage example
 
-```typescript title="src/mastra/agents/test-agent.ts"
+```typescript
 import { Memory } from "@mastra/memory";
 import { Agent } from "@mastra/core/agent";
 import { LibSQLStore, LibSQLVector } from "@mastra/libsql";
@@ -77,7 +90,7 @@ export const agent = new Agent({
 
 ## PostgreSQL with index configuration
 
-```typescript title="src/mastra/agents/pg-agent.ts"
+```typescript
 import { Memory } from "@mastra/memory";
 import { Agent } from "@mastra/core/agent";
 import { ModelRouterEmbeddingModel } from "@mastra/core/llm";
@@ -123,6 +136,7 @@ export const agent = new Agent({
 - [Getting Started with Memory](https://mastra.ai/docs/memory/overview)
 - [Semantic Recall](https://mastra.ai/docs/memory/semantic-recall)
 - [Working Memory](https://mastra.ai/docs/memory/working-memory)
+- [Observational Memory](https://mastra.ai/docs/memory/observational-memory)
 - [Memory Processors](https://mastra.ai/docs/memory/memory-processors)
 - [createThread](https://mastra.ai/reference/memory/createThread)
 - [recall](https://mastra.ai/reference/memory/recall)