@mastra/mcp-docs-server 1.1.5 → 1.1.6-alpha.0

package/.docs/guides/migrations/upgrade-to-v1/mastra.md

@@ -0,0 +1,143 @@
+# Mastra Class
+
+The Mastra class has been restructured to restrict top-level imports and replace direct property access with getter methods.
+
+## Changed
+
+### Top-level imports to subpath imports
+
+The main `@mastra/core` index file now only exports `Mastra` and `Config`. All other exports have been moved to subpath imports. This change improves tree-shaking and reduces bundle size by allowing bundlers to eliminate unused code.
+
+To migrate, update all imports from `@mastra/core` to use the appropriate subpath.
+
+```diff
+- import { Mastra, Agent, Workflow, createTool } from '@mastra/core';
++ import { Mastra, type Config } from '@mastra/core';
++ import { Agent } from '@mastra/core/agent';
++ import { Workflow } from '@mastra/core/workflows';
++ import { createTool } from '@mastra/core/tools';
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/mastra-core-imports .
+> ```
+
+### `experimental_auth` to `auth`
+
+The experimental auth configuration has been promoted to stable. This change reflects that the auth API is now stable and production-ready.
+
+To migrate, rename the `experimental_auth` key to `auth` in your Mastra configuration.
+
+```diff
+const mastra = new Mastra({
+-   experimental_auth: {
++   auth: {
+      provider: workos,
+    },
+  });
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/experimental-auth .
+> ```
+
+### Required `id` parameter for all mastra primitives
+
+All storages, vector stores, agents, workflows, mcpServers, processors, scorers, and tools now require an `id` parameter during initialization. This enables the standardized Mastra API and prevents ID conflicts.
+
+All these primitives also now have `get`, `list`, and `add` functions.
+
+To migrate, add an `id` parameter to all storage and vector store instantiations. When using the same storage/vector class multiple times, ensure each instance has a unique ID.
+
+```diff
+- const storage = new LibSQLStore({
+-   url: ':memory:',
+- });
++ const storage = new LibSQLStore({
++   id: 'my-app-storage',
++   url: ':memory:',
++ });
+
+- const vector = new PgVector({
+-   connectionString: process.env.DATABASE_URL,
+- });
++ const vector = new PgVector({
++   id: 'my-app-vector',
++   connectionString: process.env.DATABASE_URL,
++ });
+```
+
+When using separate instances for different purposes, use descriptive unique IDs:
+
+```diff
+const agentMemory = new Memory({
+    storage: new LibSQLStore({
+-     url: 'file:./agent.db',
++     id: 'weather-agent-memory-storage',
++     url: 'file:./agent.db',
+    }),
+  });
+
+  const mastra = new Mastra({
+    storage: new LibSQLStore({
++     id: 'mastra-storage',
+      url: ':memory:',
+    }),
+  });
+```
+
+### Primitive plural APIs changes from `get<primitives>` to `list<primitive>`
+
+`get*` functions that returned all instances of a primitive have been renamed to `list*` to better reflect their purpose.
+
+```diff
+- const agents = mastra.getAgents();
++ const agents = mastra.listAgents();
+- const vectors = mastra.getVectors();
++ const vectors = mastra.listVectors();
+- const workflows = mastra.getWorkflows();
++ const workflows = mastra.listWorkflows();
+- const scorers = mastra.getScorers();
++ const scorers = mastra.listScorers();
+- const mcpServers = mastra.getMCPServers();
++ const mcpServers = mastra.listMCPServers();
+- const logsByRunId = await mastra.getLogsByRunId({ runId: 'id', transportId: 'id' });
++ const logsByRunId = await mastra.listLogsByRunId({ runId: 'id', transportId: 'id' });
+- const logs = await mastra.getLogs('transportId');
++ const logs = await mastra.listLogs('transportId');
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/mastra-plural-apis .
+> ```
+
+### Each primitive has a `getById` and a `get` function
+
+```typescript
+mastra.getMCPServer('myServer') // Works (registry key)
+mastra.getMCPServerById('my-mcp-server') // Works (intrinsic ID)
+```
+
+### Tool registration now uses intrinsic IDs
+
+When tools are auto-registered from agents or MCP servers to the Mastra instance, they now use the tool's intrinsic `id` instead of the configuration object key. This prevents collisions when multiple agents/MCP servers have tools with the same configuration key.
+
+To migrate, update any code that references tools by their configuration keys to use the tool's intrinsic ID instead.
+
+```diff
+const agent = new Agent({
+    id: 'agent1',
+    tools: {
+      searchTool: weatherSearchTool,
+    },
+  });
+
+- mastra.getTool('searchTool');
++ mastra.getTool(weatherSearchTool.id);
+```

package/.docs/guides/migrations/upgrade-to-v1/mcp.md

@@ -0,0 +1,97 @@
+# MCP
+
+MCP (Model Context Protocol) tool execution context has been reorganized, and deprecated client classes have been removed.
+
+## Changed
+
+### `getMCPServers` to `listMCPServers`
+
+The `mastra.getMCPServers()` method has been renamed to `mastra.listMCPServers()`. This change aligns with the naming convention used across the API where plural getter methods use the `list` prefix.
+
+To migrate, replace all calls to `mastra.getMCPServers()` with `mastra.listMCPServers()`.
+
+```diff
+- const servers = await mastra.getMCPServers();
++ const servers = await mastra.listMCPServers();
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/mastra-plural-apis .
+> ```
+
+### `getTools` to `listTools`
+
+The `mcp.getTools()` method has been renamed to `mcp.listTools()`. This change aligns with the naming convention used across the API where plural getter methods use the `list` prefix.
+
+To migrate, replace all calls to `mcp.getTools()` with `mcp.listTools()`.
+
+```diff
+- const tools = await mcp.getTools();
++ const tools = await mcp.listTools();
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/mcp-get-tools .
+> ```
+
+### `getToolsets` to `listToolsets`
+
+The `mcp.getToolsets()` method has been renamed to `mcp.listToolsets()`. This change aligns with the naming convention used across the API where plural getter methods use the `list` prefix.
+
+To migrate, replace all calls to `mcp.getToolsets()` with `mcp.listToolsets()`.
+
+```diff
+- const toolsets = await mcp.getToolsets();
++ const toolsets = await mcp.listToolsets();
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/mcp-get-toolsets .
+> ```
+
+### MCP tool context properties organization
+
+Context properties in MCP tools are now organized under the `context.mcp` namespace. This change provides better organization and clearer API surface for MCP-specific functionality.
+
+To migrate, access MCP-specific properties like `elicitation` and `extra` through `context.mcp` instead of directly from the context parameter.
+
+```diff
+createTool({
+    id: 'account-balance',
+-   execute: async ({ context, elicitation, extra }) => {
+-     await checkAuth(extra.authInfo);
+-     const result = await elicitation.sendRequest({
+-       message: `Is it ok to fetch account ${context.accountId}?`,
+-     });
+-   },
++   execute: async (inputData, context) => {
++     await checkAuth(context?.mcp?.extra.authInfo);
++     const result = await context?.mcp?.elicitation.sendRequest({
++       message: `Is it ok to fetch account ${inputData.accountId}?`,
++     });
++   },
+  });
+```
+
+## Removed
+
+### Deprecated MCP client classes
+
+The `MastraMCPClient` and related deprecated APIs have been removed from `@mastra/mcp`. This change consolidates on the new MCP client API.
+
+To migrate, use the new `MCPClient` class instead of deprecated classes.
+
+```diff
+- import { MastraMCPClient, MCPConfiguration } from '@mastra/mcp/client';
++ import { MCPClient } from '@mastra/mcp/client';
+
+- const client = new MastraMCPClient({ ... });
+- const config = new MCPConfiguration({ ... });
++ const client = new MCPClient({ ... });
+```

package/.docs/guides/migrations/upgrade-to-v1/memory.md

@@ -0,0 +1,285 @@
+# Memory
+
+Memory configuration now requires explicit parameters, and default settings have been updated for better performance and predictability.
+
+## Changed
+
+### Default settings for semantic recall and last messages
+
+Default settings have changed to more reasonable values based on usage patterns. The `lastMessages` default decreased from 40 to 10, `semanticRecall` is now disabled by default, and thread title generation is disabled by default. These changes improve performance and reduce unexpected LLM API calls.
+
+To migrate, if you were relying on the old defaults, explicitly configure these settings.
+
+```diff
+const memory = new Memory({
+    storage,
+    vector,
+    embedder,
++   options: {
++     lastMessages: 40, // Was default before
++     semanticRecall: {
++       topK: 2,
++       messageRange: 2,
++       scope: 'thread',
++     }, // Was enabled by default before
++     generateTitle: true, // Was enabled by default before
++   },
+  });
+```
+
+### Default memory scope from `thread` to `resource`
+
+The default scope for both working memory and semantic recall has changed from `'thread'` to `'resource'`. This change aligns with common use cases where applications want to remember user information across conversations. When semantic recall is enabled, it now defaults to searching across all user conversations rather than just the current thread.
+
+To migrate, if you want to maintain the old behavior where memory is isolated per conversation thread, explicitly set `scope: 'thread'`.
+
+```diff
+const memory = new Memory({
+    storage,
+    vector,
+    embedder,
+    options: {
+      workingMemory: {
+        enabled: true,
++       scope: 'thread', // Explicitly set to thread-scoped
+        template: `# User Profile...`,
+      },
+      semanticRecall: {
+        topK: 3,
++       scope: 'thread', // Explicitly set to thread-scoped
+      },
+    },
+  });
+```
+
+### Thread title generation location
+
+The `generateTitle` option has been moved from `threads.generateTitle` to the top-level of memory options. This change simplifies the API by moving the option to where it logically belongs.
+
+To migrate, move `generateTitle` from the `threads` config to the top level of options.
+
+```diff
+const memory = new Memory({
+    storage,
+    vector,
+    embedder,
+    options: {
+-     threads: {
+-       generateTitle: true,
+-     },
++     generateTitle: true,
+    },
+  });
+```
+
+### Semantic recall default settings optimization
+
+The default settings for semantic recall have been optimized based on RAG research. The `topK` increased from 2 to 4, and `messageRange` changed from `{ before: 2, after: 2 }` to `{ before: 1, after: 1 }`. These changes provide better accuracy while only slightly increasing message count.
+
+To migrate, if you were relying on the previous defaults, explicitly set these values.
+
+```diff
+const memory = new Memory({
+    storage,
+    vector,
+    embedder,
+    options: {
+      semanticRecall: {
++       topK: 2, // Was default before
++       messageRange: { before: 2, after: 2 }, // Was default before
+      },
+    },
+  });
+```
+
+### `memory.readOnly` moved to `memory.options.readOnly`
+
+The `readOnly` property has been moved from the top-level of the memory option to inside `options`. This change aligns `readOnly` with other memory configuration options like `lastMessages` and `semanticRecall`.
+
+To migrate, move `readOnly` from the top level to inside `options`.
+
+```diff
+agent.stream('Hello', {
+    memory: {
+      thread: threadId,
+      resource: resourceId,
+-     readOnly: true,
++     options: {
++       readOnly: true,
++     },
+    },
+  });
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/memory-readonly-to-options .
+> ```
+
+### `Memory.query()` renamed to `Memory.recall()`
+
+The `Memory.query()` method has been renamed to `Memory.recall()`. The new method returns a simpler format with just `{ messages: MastraDBMessage[] }` instead of multiple format variations. This change better describes the action of retrieving messages from memory and simplifies the API.
+
+To migrate, rename `query()` to `recall()` and update code that expects the old return format.
+
+```diff
+- const result = await memory.query({ threadId: 'thread-123' });
++ const result = await memory.recall({ threadId: 'thread-123' });
+- // result: { messages: CoreMessage[], uiMessages: UIMessageWithMetadata[], messagesV2: MastraMessageV2[] }
++ // result: { messages: MastraDBMessage[] }
++ const messages = result.messages;
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/memory-query-to-recall .
+> ```
+
+### `Memory.recall()` parameter changes
+
+The `Memory.recall()` method now uses `StorageListMessagesInput` format with pagination, and the `vectorMessageSearch` parameter has been renamed to `vectorSearchString`. These changes align the memory API with the storage pagination API and provide more consistent naming.
+
+To migrate, update method name, query parameters, and the vector search parameter.
+
+```diff
+- memory.query({
++ memory.recall({
+    threadId: 'thread-123',
+-   vectorMessageSearch: 'What did we discuss?',
+-   selectBy: { ... },
++   vectorSearchString: 'What did we discuss?',
++   page: 0,
++   perPage: 20,
++   orderBy: 'createdAt',
++   filter: { ... },
++   threadConfig: { semanticRecall: true },
+  });
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/memory-vector-search-param .
+> ```
+
+### `MastraMessageV2` type renamed to `MastraDBMessage`
+
+The `MastraMessageV2` type has been renamed to `MastraDBMessage` for clarity. This change better describes the purpose of this type as the database message format.
+
+To migrate, replace all instances of `MastraMessageV2` with `MastraDBMessage`.
+
+```diff
+- import { MastraMessageV2 } from '@mastra/core';
+- function yourCustomFunction(input: MastraMessageV2) {}
++ import { MastraDBMessage } from '@mastra/core';
++ function yourCustomFunction(input: MastraDBMessage) {}
+```
+
+> **Codemod:** You can use Mastra's codemod CLI to update your code automatically:
+>
+> ```bash
+> npx @mastra/codemod@latest v1/memory-message-v2-type .
+> ```
+
+## Removed
+
+### Working memory `text-stream` mode
+
+Working memory `use: "text-stream"` option has been removed. Only `tool-call` mode is supported. This change simplifies the working memory API by removing the less reliable streaming mode.
+
+To migrate, remove the `use: "text-stream"` option. Working memory will default to tool-call mode.
+
+```diff
+const memory = new Memory({
+    storage,
+    vector,
+    embedder,
+    options: {
+      workingMemory: {
+        enabled: true,
+-       use: 'text-stream',
+        template: '...',
+      },
+    },
+  });
+```
+
+### `Memory.rememberMessages()` method
+
+The `Memory.rememberMessages()` method has been removed. This method performed the same function as `query()` (now `recall()`), and consolidating to one method simplifies the API.
+
+To migrate, replace `rememberMessages()` calls with `recall()`.
+
+```diff
+- const { messages } = await memory.rememberMessages({
++ const { messages } = await memory.recall({
+    threadId,
+    resourceId,
+  });
+```
+
+### `format` parameter from memory methods
+
+The `format` parameter has been removed from all memory get methods. `MastraDBMessage` is now the default return format everywhere. AI SDK format conversion has moved to dedicated utility functions in `@mastra/ai-sdk/ui`. This change improves tree-shaking by moving UI-specific conversion code to a separate package.
+
+To migrate, remove the `format` parameter and use conversion functions for AI SDK formats.
+
+```diff
+- const messages = await memory.getMessages({ threadId, format: 'v2' });
+- const uiMessages = await memory.getMessages({ threadId, format: 'ui' });
+
++ const result = await memory.recall({ threadId });
++ const messages = result.messages; // Always MastraDBMessage[]
++
++ // Use conversion functions for AI SDK formats
++ import { toAISdkV5Messages } from '@mastra/ai-sdk/ui';
++ const uiMessages = toAISdkV5Messages(messages);
+```
+
+### `MastraMessageV3` type
+
+The `MastraMessageV3` type and related conversion methods have been removed. Messages now convert directly between `MastraMessageV2` (now `MastraDBMessage`) and AI SDK v5 formats. This change simplifies the architecture by removing an intermediary format.
+
+To migrate, use `MastraDBMessage` for storage or AI SDK v5 message formats directly.
+
+```diff
+- import type { MastraMessageV3 } from '@mastra/core/agent';
+- const v3Messages = messageList.get.all.v3();
+
++ // For storage
++ const v2Messages = messageList.get.all.v2();
++
++ // For AI SDK v5
++ const uiMessages = messageList.get.all.aiV5.ui();
++ const modelMessages = messageList.get.all.aiV5.model();
+```
+
+### `processors` config from Memory constructor
+
+The `processors` config option in the Memory constructor has been deprecated and now throws an error. Processors should be configured at the Agent level instead. This change provides clearer configuration boundaries and better encapsulation.
+
+To migrate, move processor configuration from Memory to Agent using `inputProcessors` and/or `outputProcessors`.
+
+```diff
++ import { TokenLimiter } from '@mastra/core/processors';
++
+  const memory = new Memory({
+    storage,
+    vector,
+    embedder,
+-   processors: [/* ... */],
+  });
+
+  const agent = new Agent({
+    memory,
++   inputProcessors: [
++     new TokenLimiter({ limit: 4000 }), // Limits historical messages to fit context window
++   ],
+  });
+```
+
+Additionally, the `@mastra/memory/processors` import path has been removed. Import processors from `@mastra/core/processors` instead. See the [processors migration guide](https://mastra.ai/guides/migrations/upgrade-to-v1/processors) for details.
+
+For more information on using processors with agents, see the [Processors docs](https://mastra.ai/docs/agents/processors). For a complete example with memory, see the [TokenLimiter reference](https://mastra.ai/reference/processors/token-limiter-processor).

package/.docs/guides/migrations/upgrade-to-v1/overview.md

@@ -0,0 +1,119 @@
+# Upgrade to Mastra v1
+
+> **Update to latest 0.x version:** Before upgrading to v1, make sure you've updated to the latest 0.x version of Mastra. Follow the [upgrade to latest 0.x guide](https://mastra.ai/guides/v0/migrations/upgrade-to-latest-0x) first, then return here to complete the v1 migration.
+
+Mastra v1 was released in January 2026. We recommend starting any new projects with Mastra v1, or upgrading your existing project to continue receiving updates and support.
+
+This guide provides a comprehensive overview of breaking changes when upgrading from Mastra 0.x to v1.0. The migration is organized by package and feature area to help you systematically update your codebase.
+
+> **Need help?:** Need help with the migration? Join our [Discord community](https://discord.gg/BTYqqHKUrf) to ask questions.
+
+## Migration Strategy
+
+### Update all Mastra packages to `latest` tag
+
+Use your package manager to update your project's versions. Be sure to update **all** Mastra packages at the same time to ensure compatibility (all `@mastra/*` packages and `mastra`).
+
+Here's how you update the most commonly used packages:
+
+**npm**:
+
+```bash
+npm install @mastra/core@latest @mastra/loggers@latest @mastra/memory@latest mastra@latest
+```
+
+**pnpm**:
+
+```bash
+pnpm add @mastra/core@latest @mastra/loggers@latest @mastra/memory@latest mastra@latest
+```
+
+**Yarn**:
+
+```bash
+yarn add @mastra/core@latest @mastra/loggers@latest @mastra/memory@latest mastra@latest
+```
+
+**Bun**:
+
+```bash
+bun add @mastra/core@latest @mastra/loggers@latest @mastra/memory@latest mastra@latest
+```
+
+Install any other Mastra package with the `@latest` tag and you'll get the latest v1 version available. Be sure to update all Mastra packages (especially if you're in a monorepo) to avoid version mismatches.
+
+### Update Node.js version
+
+Mastra v1 requires Node.js **22.13.0** or higher. Update your development and production environments accordingly.
+
+### Go through migration checklist
+
+Work through the [migration checklist](#migration-checklist) below to update your codebase. Each item links to a detailed guide for that specific change.
+
+> **Codemods:** We prepared automated [codemods](https://github.com/mastra-ai/mastra/tree/main/packages/codemod) for you. If you want, you can run all v1 codemods at once:
+>
+> ```bash
+> npx @mastra/codemod@latest v1
+> ```
+
+> **Database Migration Required:** If you're using PostgreSQL or LibSQL storage, you'll need to run a database migration. See the [Storage migration guide](https://mastra.ai/guides/migrations/upgrade-to-v1/storage) for details.
+
+## Breaking Changes by Area
+
+- **[Mastra Class](https://mastra.ai/guides/migrations/upgrade-to-v1/mastra)** - Import restructuring and property access changes.
+- **[Agent Class](https://mastra.ai/guides/migrations/upgrade-to-v1/agent)** - Voice methods moved to namespace and streaming API updates.
+- **[Tools](https://mastra.ai/guides/migrations/upgrade-to-v1/tools)** - CreateTool execute signature changed to separate input and context.
+- **[Workflows](https://mastra.ai/guides/migrations/upgrade-to-v1/workflows)** - Function name changes and legacy features removed.
+- **[Memory](https://mastra.ai/guides/migrations/upgrade-to-v1/memory)** - Configuration now requires explicit parameters and defaults changed.
+- **[Storage](https://mastra.ai/guides/migrations/upgrade-to-v1/storage)** - Pagination standardized and methods renamed to list pattern.
+- **[Vectors](https://mastra.ai/guides/migrations/upgrade-to-v1/vectors)** - Vector store methods renamed to list pattern.
+- **[RAG](https://mastra.ai/guides/migrations/upgrade-to-v1/rag)** - Parameter naming updated for clarity.
+- **[MCP](https://mastra.ai/guides/migrations/upgrade-to-v1/mcp)** - Tool context reorganized and deprecated client classes removed.
+- **[Tracing](https://mastra.ai/guides/migrations/upgrade-to-v1/tracing)** - OTEL telemetry replaced with dedicated observability package and exporters.
+- **[Evals & Scorers](https://mastra.ai/guides/migrations/upgrade-to-v1/evals)** - Scorers API consolidated with new naming conventions.
+- **[CLI](https://mastra.ai/guides/migrations/upgrade-to-v1/cli)** - Commands and flags removed for simpler interface.
+- **[Deployment](https://mastra.ai/guides/migrations/upgrade-to-v1/deployment)** - CloudflareDeployer configuration updated to use standard wrangler.json property names.
+- **[Client SDKs](https://mastra.ai/guides/migrations/upgrade-to-v1/client)** - Types and utilities renamed for consistency.
+- **[Voice Packages](https://mastra.ai/guides/migrations/upgrade-to-v1/voice)** - Packages renamed from speech to voice.
+
+## Migration Checklist
+
+Work through this checklist in order, starting with high-impact changes that affect most applications.
+
+> **Codemods:** We prepared automated [codemods](https://github.com/mastra-ai/mastra/tree/main/packages/codemod) for you. Throughout the migration guide you'll find instructions on how to use them for specific changes.
+>
+> If you want, you can run all v1 codemods at once:
+>
+> ```bash
+> npx @mastra/codemod@latest v1
+> ```
+
+### High Impact Changes
+
+- Update `createTool` tool signatures to `(inputData, context)` format - [Tools](https://mastra.ai/guides/migrations/upgrade-to-v1/tools)
+- Restructure `@mastra/core` imports to use subpath imports - [Mastra Class](https://mastra.ai/guides/migrations/upgrade-to-v1/mastra)
+- Update pagination from `offset/limit` to `page/perPage` - [Storage](https://mastra.ai/guides/migrations/upgrade-to-v1/storage)
+- Install `@mastra/observability` and wrap configuration with `new Observability()` - [Tracing](https://mastra.ai/guides/migrations/upgrade-to-v1/tracing)
+- Migrate from `telemetry:` to `observability:` configuration (if upgrading from 0.x OTEL) - [Tracing](https://mastra.ai/guides/migrations/upgrade-to-v1/tracing)
+
+### Medium Impact Changes
+
+- Rename `RuntimeContext` to `RequestContext` throughout codebase - [Agent Class](https://mastra.ai/guides/migrations/upgrade-to-v1/agent), [Tools](https://mastra.ai/guides/migrations/upgrade-to-v1/tools), [Workflows](https://mastra.ai/guides/migrations/upgrade-to-v1/workflows)
+- Update storage methods from `get*` to `list*` pattern - [Storage](https://mastra.ai/guides/migrations/upgrade-to-v1/storage)
+- Replace direct property access with getter methods - [Mastra Class](https://mastra.ai/guides/migrations/upgrade-to-v1/mastra), [Agent Class](https://mastra.ai/guides/migrations/upgrade-to-v1/agent)
+- Update memory scope if relying on default `thread` scope - [Memory](https://mastra.ai/guides/migrations/upgrade-to-v1/memory)
+- Update vector store calls to use named arguments - [Storage](https://mastra.ai/guides/migrations/upgrade-to-v1/storage)
+- Remove `format` parameter from agent methods - [Agent Class](https://mastra.ai/guides/migrations/upgrade-to-v1/agent)
+- Update voice methods to use `agent.voice` namespace - [Agent Class](https://mastra.ai/guides/migrations/upgrade-to-v1/agent)
+- Rename configuration property `processors` to `spanOutputProcessors` (if using custom processors) - [Tracing](https://mastra.ai/guides/migrations/upgrade-to-v1/tracing)
+
+### Low Impact Changes
+
+- Rename `keepSeparator` to `separatorPosition` in chunk options - [RAG](https://mastra.ai/guides/migrations/upgrade-to-v1/rag)
+- Rename `createRunAsync` to `createRun` - [Workflows](https://mastra.ai/guides/migrations/upgrade-to-v1/workflows)
+- Update voice package names from `@mastra/speech-*` to `@mastra/voice-*` - [Voice Packages](https://mastra.ai/guides/migrations/upgrade-to-v1/voice)
+- Update scorer methods: `runExperiment` → `runEvals`, `getScorerByName` → `getScorerById` - [Evals & Scorers](https://mastra.ai/guides/migrations/upgrade-to-v1/evals)
+- Remove deprecated CLI flags - [CLI](https://mastra.ai/guides/migrations/upgrade-to-v1/cli)
+- Update client SDK types from `Get*` to `List*` - [Client SDKs](https://mastra.ai/guides/migrations/upgrade-to-v1/client)
+- Replace `runCount` with `retryCount` - [Workflows](https://mastra.ai/guides/migrations/upgrade-to-v1/workflows)
+- Update custom exporter method `exportEvent` to `exportTracingEvent` (if using custom exporters) - [Tracing](https://mastra.ai/guides/migrations/upgrade-to-v1/tracing)