@mastra/libsql 1.2.0-alpha.0 → 1.3.0-alpha.0

package/dist/docs/{memory/04-working-memory.md → references/docs-memory-working-memory.md}

@@ -1,8 +1,6 @@
-> Learn how to configure working memory in Mastra to store persistent user data, preferences.
-
 # Working Memory
 
-While [message history](https://mastra.ai/docs/memory/message-history) and [semantic recall](./semantic-recall) help agents remember conversations, working memory allows them to maintain persistent information about users across interactions.
+While [message history](https://mastra.ai/docs/memory/message-history) and [semantic recall](https://mastra.ai/docs/memory/semantic-recall) help agents remember conversations, working memory allows them to maintain persistent information about users across interactions.
 
 Think of it as the agent's active thoughts or scratchpad – the key information they keep available about the user or task. It's similar to how a person would naturally remember someone's name, preferences, or important details during a conversation.
 
@@ -19,7 +17,7 @@ Working memory can persist at two different scopes:
 
 Here's a minimal example of setting up an agent with working memory:
 
-```typescript {11-15}
+```typescript
 import { Agent } from "@mastra/core/agent";
 import { Memory } from "@mastra/memory";
 
@@ -43,7 +41,7 @@ const agent = new Agent({
 
 Working memory is a block of Markdown text that the agent is able to update over time to store continuously relevant information:
 
-<YouTube id="UMy_JHLf1n8" />
+[YouTube video player](https://www.youtube-nocookie.com/embed/UMy_JHLf1n8)
 
 ## Memory Persistence Scopes
 
@@ -136,7 +134,7 @@ Templates guide the agent on what information to track and update in working mem
 
 Here's an example of a custom template. In this example the agent will store the users name, location, timezone, etc as soon as the user sends a message containing any of the info:
 
-```typescript {5-28}
+```typescript
 const memory = new Memory({
   options: {
     workingMemory: {
@@ -172,19 +170,13 @@ const memory = new Memory({
 
 ## Designing Effective Templates
 
-A well-structured template keeps the information easy for the agent to parse and update. Treat the
-template as a short form that you want the assistant to keep up to date.
+A well-structured template keeps the information easy for the agent to parse and update. Treat the template as a short form that you want the assistant to keep up to date.
 
-- **Short, focused labels.** Avoid paragraphs or very long headings. Keep labels brief (for example
-  `## Personal Info` or `- Name:`) so updates are easy to read and less likely to be truncated.
-- **Use consistent casing.** Inconsistent capitalization (`Timezone:` vs `timezone:`) can cause messy
-  updates. Stick to Title Case or lower case for headings and bullet labels.
-- **Keep placeholder text simple.** Use hints such as `[e.g., Formal]` or `[Date]` to help the LLM
-  fill in the correct spots.
-- **Abbreviate very long values.** If you only need a short form, include guidance like
-  `- Name: [First name or nickname]` or `- Address (short):` rather than the full legal text.
-- **Mention update rules in `instructions`.** You can instruct how and when to fill or clear parts of
-  the template directly in the agent's `instructions` field.
+- **Short, focused labels.** Avoid paragraphs or very long headings. Keep labels brief (for example `## Personal Info` or `- Name:`) so updates are easy to read and less likely to be truncated.
+- **Use consistent casing.** Inconsistent capitalization (`Timezone:` vs `timezone:`) can cause messy updates. Stick to Title Case or lower case for headings and bullet labels.
+- **Keep placeholder text simple.** Use hints such as `[e.g., Formal]` or `[Date]` to help the LLM fill in the correct spots.
+- **Abbreviate very long values.** If you only need a short form, include guidance like `- Name: [First name or nickname]` or `- Address (short):` rather than the full legal text.
+- **Mention update rules in `instructions`.** You can instruct how and when to fill or clear parts of the template directly in the agent's `instructions` field.
 
 ### Alternative Template Styles
 
@@ -281,8 +273,7 @@ Schema-based working memory uses **merge semantics**, meaning the agent only nee
 
 ## Example: Multi-step Retention
 
-Below is a simplified view of how the `User Profile` template updates across a short user
-conversation:
+Below is a simplified view of how the `User Profile` template updates across a short user conversation:
 
 ```nohighlight
 # User Profile
@@ -308,11 +299,9 @@ conversation:
 - Timezone: CET
 ```
 
-The agent can now refer to `Sam` or `Berlin` in later responses without requesting the information
-again because it has been stored in working memory.
+The agent can now refer to `Sam` or `Berlin` in later responses without requesting the information again because it has been stored in working memory.
 
-If your agent is not properly updating working memory when you expect it to, you can add system
-instructions on _how_ and _when_ to use this template in your agent's `instructions` setting.
+If your agent is not properly updating working memory when you expect it to, you can add system instructions on _how_ and _when_ to use this template in your agent's `instructions` setting.
 
 ## Setting Initial Working Memory
 
@@ -322,7 +311,7 @@ While agents typically update working memory through the `updateWorkingMemory` t
 
 When creating a thread, you can provide initial working memory through the metadata's `workingMemory` key:
 
-```typescript title="src/app/medical-consultation.ts"
+```typescript
 // Create a thread with initial working memory
 const thread = await memory.createThread({
   threadId: "thread-123",
@@ -353,7 +342,7 @@ await agent.generate("What's my blood type?", {
 
 You can also update an existing thread's working memory:
 
-```typescript title="src/app/medical-consultation.ts"
+```typescript
 // Update thread metadata to add/modify working memory
 await memory.updateThread({
   id: "thread-123",
@@ -375,7 +364,7 @@ await memory.updateThread({
 
 Alternatively, use the `updateWorkingMemory` method directly:
 
-```typescript title="src/app/medical-consultation.ts"
+```typescript
 await memory.updateWorkingMemory({
   threadId: "thread-123",
   resourceId: "user-456", // Required for resource-scoped memory

package/dist/docs/{observability/01-overview.md → references/docs-observability-overview.md}

@@ -1,5 +1,3 @@
-> Monitor and debug applications with Mastra
-
 # Observability Overview
 
 Mastra provides observability features for AI applications. Monitor LLM operations, trace agent decisions, and debug complex workflows with tools that understand AI-specific patterns.
@@ -17,15 +15,15 @@ Specialized tracing for AI operations that captures:
 
 ## Storage Requirements
 
-The `DefaultExporter` persists traces to your configured storage backend. Not all storage providers support observability—for the full list, see [Storage Provider Support](https://mastra.ai/docs/observability/tracing/exporters/default#storage-provider-support).
+The `DefaultExporter` persists traces to your configured storage backend. Not all storage providers support observability—for the full list, see [Storage Provider Support](https://mastra.ai/docs/observability/tracing/exporters/default).
 
-For production environments with high traffic, we recommend using **ClickHouse** for the observability domain via [composite storage](https://mastra.ai/reference/storage/composite). See [Production Recommendations](https://mastra.ai/docs/observability/tracing/exporters/default#production-recommendations) for details.
+For production environments with high traffic, we recommend using **ClickHouse** for the observability domain via [composite storage](https://mastra.ai/reference/storage/composite). See [Production Recommendations](https://mastra.ai/docs/observability/tracing/exporters/default) for details.
 
 ## Quick Start
 
 Configure Observability in your Mastra instance:
 
-```typescript title="src/mastra/index.ts"
+```typescript
 import { Mastra } from "@mastra/core";
 import { PinoLogger } from "@mastra/loggers";
 import { LibSQLStore } from "@mastra/libsql";
@@ -59,8 +57,7 @@ export const mastra = new Mastra({
 });
 ```
 
-> **Serverless environments**
-The `file:./mastra.db` storage URL uses the local filesystem, which doesn't work in serverless environments like Vercel, AWS Lambda, or Cloudflare Workers. For serverless deployments, use external storage. See the [Vercel deployment guide](https://mastra.ai/guides/deployment/vercel-deployer#observability) for a complete example.
+> **Serverless environments:** The `file:./mastra.db` storage URL uses the local filesystem, which doesn't work in serverless environments like Vercel, AWS Lambda, or Cloudflare Workers. For serverless deployments, use external storage. See the [Vercel deployment guide](https://mastra.ai/guides/deployment/vercel) for a complete example.
 
 With this basic setup, you will see Traces and Logs in both Studio and in Mastra Cloud.
 

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)