@mastra/libsql 1.0.0 → 1.1.0-alpha.0

package/dist/docs/memory/{04-semantic-recall.md → 05-semantic-recall.md}

@@ -37,9 +37,32 @@ const agent = new Agent({
 });
 ```
 
+## 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 just recency, use `recall()` with a `vectorSearchString`:
+
+```typescript
+const memory = await agent.getMemory();
+
+// Basic recall - similar to listMessages
+const { messages } = await memory!.recall({
+  threadId: "thread-123",
+  perPage: 50,
+});
+
+// Semantic recall - find messages by meaning
+const { messages: relevantMessages } = await memory!.recall({
+  threadId: "thread-123",
+  vectorSearchString: "What did we discuss about the project deadline?",
+  threadConfig: {
+    semanticRecall: true,
+  },
+});
+```
+
 ## Storage configuration
 
-Semantic recall relies on a [storage and vector db](https://mastra.ai/reference/v1/memory/memory-class) to store messages and their embeddings.
+Semantic recall relies on a [storage and vector db](https://mastra.ai/reference/memory/memory-class) to store messages and their embeddings.
 
 ```ts {8-16}
 import { Memory } from "@mastra/memory";
@@ -64,23 +87,23 @@ const agent = new Agent({
 
 Each vector store page below includes installation instructions, configuration parameters, and usage examples:
 
-- [Astra](https://mastra.ai/reference/v1/vectors/astra)
-- [Chroma](https://mastra.ai/reference/v1/vectors/chroma)
-- [Cloudflare Vectorize](https://mastra.ai/reference/v1/vectors/vectorize)
-- [Convex](https://mastra.ai/reference/v1/vectors/convex)
-- [Couchbase](https://mastra.ai/reference/v1/vectors/couchbase)
-- [DuckDB](https://mastra.ai/reference/v1/vectors/duckdb)
-- [Elasticsearch](https://mastra.ai/reference/v1/vectors/elasticsearch)
-- [LanceDB](https://mastra.ai/reference/v1/vectors/lance)
-- [libSQL](https://mastra.ai/reference/v1/vectors/libsql)
-- [MongoDB](https://mastra.ai/reference/v1/vectors/mongodb)
-- [OpenSearch](https://mastra.ai/reference/v1/vectors/opensearch)
-- [Pinecone](https://mastra.ai/reference/v1/vectors/pinecone)
-- [PostgreSQL](https://mastra.ai/reference/v1/vectors/pg)
-- [Qdrant](https://mastra.ai/reference/v1/vectors/qdrant)
-- [S3 Vectors](https://mastra.ai/reference/v1/vectors/s3vectors)
-- [Turbopuffer](https://mastra.ai/reference/v1/vectors/turbopuffer)
-- [Upstash](https://mastra.ai/reference/v1/vectors/upstash)
+- [Astra](https://mastra.ai/reference/vectors/astra)
+- [Chroma](https://mastra.ai/reference/vectors/chroma)
+- [Cloudflare Vectorize](https://mastra.ai/reference/vectors/vectorize)
+- [Convex](https://mastra.ai/reference/vectors/convex)
+- [Couchbase](https://mastra.ai/reference/vectors/couchbase)
+- [DuckDB](https://mastra.ai/reference/vectors/duckdb)
+- [Elasticsearch](https://mastra.ai/reference/vectors/elasticsearch)
+- [LanceDB](https://mastra.ai/reference/vectors/lance)
+- [libSQL](https://mastra.ai/reference/vectors/libsql)
+- [MongoDB](https://mastra.ai/reference/vectors/mongodb)
+- [OpenSearch](https://mastra.ai/reference/vectors/opensearch)
+- [Pinecone](https://mastra.ai/reference/vectors/pinecone)
+- [PostgreSQL](https://mastra.ai/reference/vectors/pg)
+- [Qdrant](https://mastra.ai/reference/vectors/qdrant)
+- [S3 Vectors](https://mastra.ai/reference/vectors/s3vectors)
+- [Turbopuffer](https://mastra.ai/reference/vectors/turbopuffer)
+- [Upstash](https://mastra.ai/reference/vectors/upstash)
 
 ## Recall configuration
 
@@ -106,7 +129,7 @@ const agent = new Agent({
 
 ## Embedder configuration
 
-Semantic recall relies on an [embedding model](https://mastra.ai/reference/v1/memory/memory-class) to convert messages into embeddings. Mastra supports embedding models through the model router using `provider/model` strings, or you can use any [embedding model](https://sdk.vercel.ai/docs/ai-sdk-core/embeddings) compatible with the AI SDK.
+Semantic recall relies on an [embedding model](https://mastra.ai/reference/memory/memory-class) to convert messages into embeddings. Mastra supports embedding models through the model router using `provider/model` strings, or you can use any [embedding model](https://sdk.vercel.ai/docs/ai-sdk-core/embeddings) compatible with the AI SDK.
 
 #### Using the Model Router (Recommended)
 
@@ -127,7 +150,7 @@ const agent = new Agent({
 Supported embedding models:
 
 - **OpenAI**: `text-embedding-3-small`, `text-embedding-3-large`, `text-embedding-ada-002`
-- **Google**: `gemini-embedding-001`, `text-embedding-004`
+- **Google**: `gemini-embedding-001`
 
 The model router automatically handles API key detection from environment variables (`OPENAI_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`).
 
@@ -152,7 +175,7 @@ const agent = new Agent({
 To use FastEmbed (a local embedding model), install `@mastra/fastembed`:
 
 ```bash npm2yarn
-npm install @mastra/fastembed@beta
+npm install @mastra/fastembed@latest
 ```
 
 Then configure it in your memory:
@@ -205,7 +228,7 @@ const agent = new Agent({
 });
 ```
 
-For detailed information about index configuration options and performance tuning, see the [PgVector configuration guide](https://mastra.ai/reference/v1/vectors/pg#index-configuration-guide).
+For detailed information about index configuration options and performance tuning, see the [PgVector configuration guide](https://mastra.ai/reference/vectors/pg#index-configuration-guide).
 
 ## Disabling
 

package/dist/docs/memory/{05-memory-processors.md → 06-memory-processors.md}

@@ -6,7 +6,7 @@ Memory processors transform and filter messages as they pass through an agent wi
 
 When memory is enabled on an agent, Mastra adds memory processors to the agent's processor pipeline. These processors retrieve message history, working memory, and semantically relevant messages, then persist new messages after the model responds.
 
-Memory processors are [processors](https://mastra.ai/docs/v1/agents/processors) that operate specifically on memory-related messages and state.
+Memory processors are [processors](https://mastra.ai/docs/agents/processors) that operate specifically on memory-related messages and state.
 
 ## Built-in Memory Processors
 
@@ -311,8 +311,8 @@ Both scenarios are safe - guardrails prevent inappropriate content from being pe
 
 ## Related documentation
 
-- [Processors](https://mastra.ai/docs/v1/agents/processors) - General processor concepts and custom processor creation
-- [Guardrails](https://mastra.ai/docs/v1/agents/guardrails) - Security and validation processors
-- [Memory Overview](https://mastra.ai/docs/v1/memory/overview) - Memory types and configuration
+- [Processors](https://mastra.ai/docs/agents/processors) - General processor concepts and custom processor creation
+- [Guardrails](https://mastra.ai/docs/agents/guardrails) - Security and validation processors
+- [Memory Overview](https://mastra.ai/docs/memory/overview) - Memory types and configuration
 
 When creating custom processors avoid mutating the input `messages` array or its objects directly.

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

@@ -120,14 +120,14 @@ export const agent = new Agent({
 
 ### Related
 
-- [Getting Started with Memory](https://mastra.ai/docs/v1/memory/overview)
-- [Semantic Recall](https://mastra.ai/docs/v1/memory/semantic-recall)
-- [Working Memory](https://mastra.ai/docs/v1/memory/working-memory)
-- [Memory Processors](https://mastra.ai/docs/v1/memory/memory-processors)
-- [createThread](https://mastra.ai/reference/v1/memory/createThread)
-- [recall](https://mastra.ai/reference/v1/memory/recall)
-- [getThreadById](https://mastra.ai/reference/v1/memory/getThreadById)
-- [listThreads](https://mastra.ai/reference/v1/memory/listThreads)
-- [deleteMessages](https://mastra.ai/reference/v1/memory/deleteMessages)
-- [cloneThread](https://mastra.ai/reference/v1/memory/cloneThread)
-- [Clone Utility Methods](https://mastra.ai/reference/v1/memory/clone-utilities)
+- [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)
+- [Memory Processors](https://mastra.ai/docs/memory/memory-processors)
+- [createThread](https://mastra.ai/reference/memory/createThread)
+- [recall](https://mastra.ai/reference/memory/recall)
+- [getThreadById](https://mastra.ai/reference/memory/getThreadById)
+- [listThreads](https://mastra.ai/reference/memory/listThreads)
+- [deleteMessages](https://mastra.ai/reference/memory/deleteMessages)
+- [cloneThread](https://mastra.ai/reference/memory/cloneThread)
+- [Clone Utility Methods](https://mastra.ai/reference/memory/clone-utilities)

package/dist/docs/observability/01-overview.md

@@ -15,6 +15,12 @@ Specialized tracing for AI operations that captures:
 - **Workflow steps**: Branching logic, parallel execution, and step outputs
 - **Automatic instrumentation**: Tracing with decorators
 
+## 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).
+
+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.
+
 ## Quick Start
 
 Configure Observability in your Mastra instance:
@@ -53,12 +59,15 @@ 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.
+
 With this basic setup, you will see Traces and Logs in both Studio and in Mastra Cloud.
 
-We also support various external tracing providers like MLflow, Langfuse, Braintrust, and any OpenTelemetry-compatible platform (Datadog, New Relic, SigNoz, etc.). See more about this in the [Tracing](https://mastra.ai/docs/v1/observability/tracing/overview) documentation.
+We also support various external tracing providers like MLflow, Langfuse, Braintrust, and any OpenTelemetry-compatible platform (Datadog, New Relic, SigNoz, etc.). See more about this in the [Tracing](https://mastra.ai/docs/observability/tracing/overview) documentation.
 
 ## What's Next?
 
-- **[Set up Tracing](https://mastra.ai/docs/v1/observability/tracing/overview)**: Configure tracing for your application
-- **[Configure Logging](https://mastra.ai/docs/v1/observability/logging)**: Add structured logging
-- **[API Reference](https://mastra.ai/reference/v1/observability/tracing/instances)**: Detailed configuration options
+- **[Set up Tracing](https://mastra.ai/docs/observability/tracing/overview)**: Configure tracing for your application
+- **[Configure Logging](https://mastra.ai/docs/observability/logging)**: Add structured logging
+- **[API Reference](https://mastra.ai/reference/observability/tracing/instances)**: Detailed configuration options

package/dist/docs/observability/02-default.md

@@ -4,6 +4,9 @@
 
 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.
+
 ## Configuration
 
 ### Prerequisites
@@ -110,14 +113,30 @@ new DefaultExporter({
 
 ## Storage Provider Support
 
-Different storage providers support different tracing strategies.
+Different storage providers support different tracing strategies. Some providers support observability for production workloads, while others are intended primarily for local development.
 
 If you set the strategy to `'auto'`, the `DefaultExporter` automatically selects the optimal strategy for the storage provider. If you set the strategy to a mode that the storage provider doesn't support, you will get an error message.
 
-| Storage Provider                                | Preferred Strategy | Supported Strategies                      | Notes                                 |
+### Providers with Observability Support
+
+| Storage Provider                                | Preferred Strategy | Supported Strategies                      | Recommended Use                       |
 | ----------------------------------------------- | ------------------ | ----------------------------------------- | ------------------------------------- |
-| **[libSQL](https://mastra.ai/reference/v1/storage/libsql)**         | batch-with-updates | realtime, batch-with-updates, insert-only | Default storage, good for development |
-| **[PostgreSQL](https://mastra.ai/reference/v1/storage/postgresql)** | batch-with-updates | batch-with-updates, insert-only           | Recommended for production            |
+| **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
+
+The following storage providers **do not support** the observability domain. If you're using one of these providers and need observability, use [composite storage](https://mastra.ai/reference/storage/composite) to route observability data to a supported provider:
+
+- [Convex](https://mastra.ai/reference/storage/convex)
+- [DynamoDB](https://mastra.ai/reference/storage/dynamodb)
+- [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1)
+- [Cloudflare Durable Objects](https://mastra.ai/reference/storage/cloudflare)
+- [Upstash](https://mastra.ai/reference/storage/upstash)
+- [LanceDB](https://mastra.ai/reference/storage/lance)
 
 ### Strategy Benefits
 
@@ -125,6 +144,23 @@ If you set the strategy to `'auto'`, the `DefaultExporter` automatically selects
 - **batch-with-updates**: 10-100x throughput improvement, full span lifecycle
 - **insert-only**: Additional 70% reduction in database operations, perfect for analytics
 
+## Production Recommendations
+
+Observability data grows quickly in production environments. A single agent interaction can generate hundreds of spans, and high-traffic applications can produce thousands of traces per day. Most general-purpose databases aren't optimized for this write-heavy, append-only workload.
+
+### 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:
+
+- **Optimized for writes**: Handles millions of inserts per second
+- **Efficient compression**: Reduces storage costs for trace data
+- **Fast queries**: Columnar storage enables quick trace lookups and aggregations
+- **Time-series native**: Built-in support for time-based data retention and partitioning
+
+### 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.
+
 ## Batching Behavior
 
 ### Flush Triggers
@@ -172,6 +208,7 @@ new DefaultExporter({
 
 ## Related
 
-- [Tracing Overview](https://mastra.ai/docs/v1/observability/tracing/overview)
-- [CloudExporter](https://mastra.ai/docs/v1/observability/tracing/exporters/cloud)
-- [Storage Configuration](https://mastra.ai/docs/v1/memory/storage)
+- [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview)
+- [CloudExporter](https://mastra.ai/docs/observability/tracing/exporters/cloud)
+- [Composite Storage](https://mastra.ai/reference/storage/composite) - Combine multiple storage providers
+- [Storage Configuration](https://mastra.ai/docs/memory/storage)

package/dist/docs/rag/01-retrieval.md

@@ -73,7 +73,7 @@ Filter results based on metadata fields to narrow down the search space. This ap
 
 This is useful when you have documents from different sources, time periods, or with specific attributes. Mastra provides a unified MongoDB-style query syntax that works across all supported vector stores.
 
-For detailed information about available operators and syntax, see the [Metadata Filters Reference](https://mastra.ai/reference/v1/rag/metadata-filters).
+For detailed information about available operators and syntax, see the [Metadata Filters Reference](https://mastra.ai/reference/rag/metadata-filters).
 
 Basic filtering examples:
 
@@ -264,7 +264,7 @@ await pineconeQueryTool.execute(
 );
 ```
 
-For detailed configuration options and advanced usage, see the [Vector Query Tool Reference](https://mastra.ai/reference/v1/tools/vector-query-tool).
+For detailed configuration options and advanced usage, see the [Vector Query Tool Reference](https://mastra.ai/reference/tools/vector-query-tool).
 
 ### Vector Store Prompts
 
@@ -543,6 +543,6 @@ const relevanceProvider = new ZeroEntropyRelevanceScorer("zerank-1");
 
 The re-ranked results combine vector similarity with semantic understanding to improve retrieval quality.
 
-For more details about re-ranking, see the [rerank()](https://mastra.ai/reference/v1/rag/rerankWithScorer) method.
+For more details about re-ranking, see the [rerank()](https://mastra.ai/reference/rag/rerankWithScorer) method.
 
-For graph-based retrieval that follows connections between chunks, see the [GraphRAG](https://mastra.ai/docs/v1/rag/graph-rag) documentation.
+For graph-based retrieval that follows connections between chunks, see the [GraphRAG](https://mastra.ai/docs/rag/graph-rag) documentation.

package/dist/docs/storage/01-reference.md

@@ -15,14 +15,14 @@
 
 `MastraCompositeStore` is included in `@mastra/core`:
 
-```bash
-npm install @mastra/core@beta
+```bash npm2yarn
+npm install @mastra/core@latest
 ```
 
 You'll also need to install the storage providers you want to compose:
 
-```bash
-npm install @mastra/pg@beta @mastra/libsql@beta
+```bash npm2yarn
+npm install @mastra/pg@latest @mastra/libsql@latest
 ```
 
 ## Storage domains
@@ -159,7 +159,9 @@ const storage = new MastraCompositeStore({
 
 ### Specialized storage for observability
 
-Use a time-series database for traces while keeping other data in PostgreSQL:
+Observability data can quickly overwhelm general-purpose databases in production. A single agent interaction can generate hundreds of spans, and high-traffic applications can produce thousands of traces per day.
+
+**ClickHouse** is recommended for production observability because it's optimized for high-volume, write-heavy analytics workloads. Use composite storage to route observability to ClickHouse while keeping other data in your primary database:
 
 ```typescript
 import { MastraCompositeStore } from "@mastra/core/storage";
@@ -181,6 +183,10 @@ const storage = new MastraCompositeStore({
 });
 ```
 
+> **Note:**
+
+This approach is also required when using storage providers that don't support observability (like Convex, DynamoDB, or Cloudflare). See the [DefaultExporter documentation](https://mastra.ai/docs/observability/tracing/exporters/default#storage-provider-support) for the full list of supported providers.
+
 ---
 
 ## Reference: DynamoDB Storage
@@ -189,24 +195,26 @@ const storage = new MastraCompositeStore({
 
 The DynamoDB storage implementation provides a scalable and performant NoSQL database solution for Mastra, leveraging a single-table design pattern with [ElectroDB](https://electrodb.dev/).
 
+> **Observability Not Supported**
+DynamoDB storage **does not support the observability domain**. Traces from the `DefaultExporter` cannot be persisted to DynamoDB, and Mastra Studio's observability features won't work with DynamoDB as your only storage provider. To enable observability, use [composite storage](https://mastra.ai/reference/storage/composite#specialized-storage-for-observability) to route observability data to a supported provider like ClickHouse or PostgreSQL.
+
+> **Item Size Limit**
+DynamoDB enforces a **400 KB maximum item size**. This limit can be exceeded when storing messages with base64-encoded attachments such as images. See [Handling large attachments](https://mastra.ai/docs/memory/storage#handling-large-attachments) for workarounds including uploading attachments to external storage.
+
 ## Features
 
 - Efficient single-table design for all Mastra storage needs
 - Based on ElectroDB for type-safe DynamoDB access
 - Support for AWS credentials, regions, and endpoints
 - Compatible with AWS DynamoDB Local for development
-- Stores Thread, Message, Trace, Eval, and Workflow data
+- Stores Thread, Message, Eval, and Workflow data
 - Optimized for serverless environments
 - Configurable TTL (Time To Live) for automatic data expiration per entity type
 
 ## Installation
 
-```bash
-npm install @mastra/dynamodb@beta
-# or
-pnpm add @mastra/dynamodb@beta
-# or
-yarn add @mastra/dynamodb@beta
+```bash npm2yarn
+npm install @mastra/dynamodb@latest
 ```
 
 ## Prerequisites
@@ -438,14 +446,14 @@ This implementation uses a single-table design pattern with ElectroDB, which off
 
 [libSQL](https://docs.turso.tech/libsql) is an open-source, SQLite-compatible database that supports both local and remote deployments. It can be used to store message history, workflow snapshots, traces, and eval scores.
 
-For vectors like semantic recall or traditional RAG, use [libSQL Vector](https://mastra.ai/reference/v1/vectors/libsql) which covers embeddings and vector search.
+For vectors like semantic recall or traditional RAG, use [libSQL Vector](https://mastra.ai/reference/vectors/libsql) which covers embeddings and vector search.
 
 ## Installation
 
 Storage providers must be installed as separate packages:
 
-```bash
-npm install @mastra/libsql@beta
+```bash npm2yarn
+npm install @mastra/libsql@latest
 ```
 
 ## Usage
@@ -508,7 +516,7 @@ In-memory storage resets when the process changes. Only suitable for development
 
 ## Initialization
 
-When you pass storage to the Mastra class, `init()` is called automatically to create the [core schema](https://mastra.ai/reference/v1/storage/overview#core-schema):
+When you pass storage to the Mastra class, `init()` is called automatically to create the [core schema](https://mastra.ai/reference/storage/overview#core-schema):
 
 ```typescript 
 import { Mastra } from "@mastra/core";
@@ -539,4 +547,10 @@ await storage.init();
 // Access domain-specific stores via getStore()
 const memoryStore = await storage.getStore('memory');
 const thread = await memoryStore?.getThreadById({ threadId: "..." });
-```
+```
+
+## Observability
+
+libSQL supports observability and is ideal for local development. Use the `realtime` [tracing strategy](https://mastra.ai/docs/observability/tracing/exporters/default#tracing-strategies) for immediate visibility while debugging.
+
+For production environments with higher trace volumes, consider using [PostgreSQL](https://mastra.ai/reference/storage/postgresql) or [ClickHouse via composite storage](https://mastra.ai/reference/storage/composite#specialized-storage-for-observability).

package/dist/docs/vectors/01-reference.md

@@ -14,8 +14,8 @@ It's part of the `@mastra/libsql` package and offers efficient vector similarity
 
 ## Installation
 
-```bash
-npm install @mastra/libsql@beta
+```bash npm2yarn
+npm install @mastra/libsql@latest
 ```
 
 ## Usage
@@ -168,8 +168,8 @@ Embeddings are numeric vectors used by memory's `semanticRecall` to retrieve rel
 
 Install `fastembed` to get started:
 
-```bash 
-npm install @mastra/fastembed@beta
+```bash npm2yarn
+npm install @mastra/fastembed@latest
 ```
 
 Add the following to your agent:

package/dist/docs/workflows/01-snapshots.md

@@ -85,9 +85,9 @@ Snapshots are saved to the configured storage system. By default, they use libSQ
 
 Read more about:
 
-- [libSQL Storage](https://mastra.ai/reference/v1/storage/libsql)
-- [Upstash Storage](https://mastra.ai/reference/v1/storage/upstash)
-- [PostgreSQL Storage](https://mastra.ai/reference/v1/storage/postgresql)
+- [libSQL Storage](https://mastra.ai/reference/storage/libsql)
+- [Upstash Storage](https://mastra.ai/reference/storage/upstash)
+- [PostgreSQL Storage](https://mastra.ai/reference/storage/postgresql)
 
 ### Saving snapshots
 
@@ -139,13 +139,13 @@ export const mastra = new Mastra({
 });
 ```
 
-- [libSQL Storage](https://mastra.ai/reference/v1/storage/libsql)
-- [PostgreSQL Storage](https://mastra.ai/reference/v1/storage/postgresql)
-- [MongoDB Storage](https://mastra.ai/reference/v1/storage/mongodb)
-- [Upstash Storage](https://mastra.ai/reference/v1/storage/upstash)
-- [Cloudflare D1](https://mastra.ai/reference/v1/storage/cloudflare-d1)
-- [DynamoDB](https://mastra.ai/reference/v1/storage/dynamodb)
-- [More storage providers](https://mastra.ai/docs/v1/memory/storage)
+- [libSQL Storage](https://mastra.ai/reference/storage/libsql)
+- [PostgreSQL Storage](https://mastra.ai/reference/storage/postgresql)
+- [MongoDB Storage](https://mastra.ai/reference/storage/mongodb)
+- [Upstash Storage](https://mastra.ai/reference/storage/upstash)
+- [Cloudflare D1](https://mastra.ai/reference/storage/cloudflare-d1)
+- [DynamoDB](https://mastra.ai/reference/storage/dynamodb)
+- [More storage providers](https://mastra.ai/docs/memory/storage)
 
 ## Best practices
 
@@ -234,7 +234,7 @@ if (result.status === "suspended") {
 
 ## Related
 
-- [Control Flow](https://mastra.ai/docs/v1/workflows/control-flow)
-- [Suspend & Resume](https://mastra.ai/docs/v1/workflows/suspend-and-resume)
-- [Time Travel](https://mastra.ai/docs/v1/workflows/time-travel)
-- [Human-in-the-loop](https://mastra.ai/docs/v1/workflows/human-in-the-loop)
+- [Control Flow](https://mastra.ai/docs/workflows/control-flow)
+- [Suspend & Resume](https://mastra.ai/docs/workflows/suspend-and-resume)
+- [Time Travel](https://mastra.ai/docs/workflows/time-travel)
+- [Human-in-the-loop](https://mastra.ai/docs/workflows/human-in-the-loop)