@mastra/mcp-docs-server 0.13.29 → 0.13.30-alpha.1

package/.docs/raw/agents/adding-voice.mdx

@@ -2,7 +2,7 @@
 
 Mastra agents can be enhanced with voice capabilities, allowing them to speak responses and listen to user input. You can configure an agent to use either a single voice provider or combine multiple providers for different operations.
 
-## Using a Single Provider
+## Basic usage
 
 The simplest way to add voice to an agent is to use a single provider for both speaking and listening:
 
@@ -39,30 +39,6 @@ try {
 }
 ```
 
-## Using Multiple Providers
-
-For more flexibility, you can use different providers for speaking and listening using the CompositeVoice class:
-
-```typescript
-import { Agent } from "@mastra/core/agent";
-import { CompositeVoice } from "@mastra/core/voice";
-import { OpenAIVoice } from "@mastra/voice-openai";
-import { PlayAIVoice } from "@mastra/voice-playai";
-import { openai } from "@ai-sdk/openai";
-
-export const agent = new Agent({
-  name: "Agent",
-  instructions: `You are a helpful assistant with both STT and TTS capabilities.`,
-  model: openai("gpt-4o"),
-
-  // Create a composite voice using OpenAI for listening and PlayAI for speaking
-  voice: new CompositeVoice({
-    input: new OpenAIVoice(),
-    output: new PlayAIVoice(),
-  }),
-});
-```
-
 ## Working with Audio Streams
 
 The `speak()` and `listen()` methods work with Node.js streams. Here's how to save and load audio files:
@@ -176,6 +152,123 @@ agent.voice.on("error", (error) => {
 });
 ```
 
+## Examples
+
+### End-to-end voice interaction
+
+This example demonstrates a voice interaction between two agents. The hybrid voice agent, which uses multiple providers, speaks a question, which is saved as an audio file. The unified voice agent listens to that file, processes the question, generates a response, and speaks it back. Both audio outputs are saved to the `audio` directory.
+
+The following files are created:
+
+- **hybrid-question.mp3** – Hybrid agent's spoken question.
+- **unified-response.mp3** – Unified agent's spoken response.
+
+```typescript filename="src/test-voice-agents.ts" showLineNumbers copy
+import "dotenv/config";
+
+import path from "path";
+import { createReadStream } from "fs";
+import { Agent } from "@mastra/core/agent";
+import { CompositeVoice } from "@mastra/core/voice";
+import { OpenAIVoice } from "@mastra/voice-openai";
+import { Mastra } from "@mastra/core/mastra";
+import { openai } from "@ai-sdk/openai";
+
+// Saves an audio stream to a file in the audio directory, creating the directory if it doesn't exist.
+export const saveAudioToFile = async (audio: NodeJS.ReadableStream, filename: string): Promise<void> => {
+  const audioDir = path.join(process.cwd(), "audio");
+  const filePath = path.join(audioDir, filename);
+
+  await fs.promises.mkdir(audioDir, { recursive: true });
+
+  const writer = createWriteStream(filePath);
+  audio.pipe(writer);
+  return new Promise((resolve, reject) => {
+    writer.on("finish", resolve);
+    writer.on("error", reject);
+  });
+};
+
+// Saves an audio stream to a file in the audio directory, creating the directory if it doesn't exist.
+export const convertToText = async (input: string | NodeJS.ReadableStream): Promise<string> => {
+  if (typeof input === "string") {
+    return input;
+  }
+
+  const chunks: Buffer[] = [];
+  return new Promise((resolve, reject) => {
+    input.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    input.on("error", reject);
+    input.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
+  });
+};
+
+export const hybridVoiceAgent = new Agent({
+  name: "hybrid-voice-agent",
+  model: openai("gpt-4o"),
+  instructions: "You can speak and listen using different providers.",
+  voice: new CompositeVoice({
+    input: new OpenAIVoice(),
+    output: new OpenAIVoice()
+  })
+});
+ 
+export const unifiedVoiceAgent = new Agent({
+  name: "unified-voice-agent",
+  instructions: "You are an agent with both STT and TTS capabilities.",
+  model: openai("gpt-4o"),
+  voice: new OpenAIVoice()
+});
+
+export const mastra = new Mastra({
+  // ...
+  agents: { hybridVoiceAgent, unifiedVoiceAgent }
+});
+
+const hybridVoiceAgent = mastra.getAgent("hybridVoiceAgent");
+const unifiedVoiceAgent = mastra.getAgent("unifiedVoiceAgent");
+
+const question = "What is the meaning of life in one sentence?";
+
+const hybridSpoken = await hybridVoiceAgent.voice.speak(question);
+
+await saveAudioToFile(hybridSpoken!, "hybrid-question.mp3");
+
+const audioStream = createReadStream(path.join(process.cwd(), "audio", "hybrid-question.mp3"));
+const unifiedHeard = await unifiedVoiceAgent.voice.listen(audioStream);
+
+const inputText = await convertToText(unifiedHeard!);
+
+const unifiedResponse = await unifiedVoiceAgent.generate(inputText);
+const unifiedSpoken = await unifiedVoiceAgent.voice.speak(unifiedResponse.text);
+
+await saveAudioToFile(unifiedSpoken!, "unified-response.mp3");
+```
+
+### Using Multiple Providers
+
+For more flexibility, you can use different providers for speaking and listening using the CompositeVoice class:
+
+```typescript
+import { Agent } from "@mastra/core/agent";
+import { CompositeVoice } from "@mastra/core/voice";
+import { OpenAIVoice } from "@mastra/voice-openai";
+import { PlayAIVoice } from "@mastra/voice-playai";
+import { openai } from "@ai-sdk/openai";
+
+export const agent = new Agent({
+  name: "Agent",
+  instructions: `You are a helpful assistant with both STT and TTS capabilities.`,
+  model: openai("gpt-4o"),
+
+  // Create a composite voice using OpenAI for listening and PlayAI for speaking
+  voice: new CompositeVoice({
+    input: new OpenAIVoice(),
+    output: new PlayAIVoice(),
+  }),
+});
+```
+
 ## Supported Voice Providers
 
 Mastra supports multiple voice providers for text-to-speech (TTS) and speech-to-text (STT) capabilities:

package/.docs/raw/agents/agent-memory.mdx

@@ -1,40 +1,80 @@
 ---
-title: "Using Agent Memory | Agents | Mastra Docs"
-description: Documentation on how agents in Mastra use memory to store conversation history and contextual information.
+title: "Agent Memory | Agents | Mastra Docs"
+description: Learn how to add memory to agents to store conversation history and maintain context across interactions.
 ---
 
+import { Callout } from "nextra/components";
+
 # Agent Memory
 
-Agents in Mastra can leverage a powerful memory system to store conversation history, recall relevant information, and maintain persistent context across interactions. This allows agents to have more natural, stateful conversations.
+Agents can use memory to store conversation history, recall relevant information, and maintain context across interactions. This enables more natural, stateful conversations throughout a user’s session.
+
+## When to use memory
+
+Use memory when an agent needs to retain information across multiple user interactions. This includes recalling user-specific details, facts, or tool calls and their results. Without memory, the agent handles each request in isolation, with no awareness of previous messages or responses.
+
+For more information about the different ways memory works in Mastra see the following pages.
+
+- [Working Memory](../memory/working-memory.mdx)
+- [Semantic Recall](../memory/semantic-recall.mdx)
+
+## Prerequisites
 
-## Enabling memory for an agent
+Memory requires a storage provider to persist conversation history, including user messages and agent responses. You can use **shared storage** to define a single provider for all agents, or **dedicated storage** to configure separate providers for individual agents.
 
-To enable memory, instantiate the `Memory` class and pass it to your agent's configuration using the `memory` parameter. You also need to install the memory package and a storage adapter:
+Install `@mastra/memory` and a storage provider.
 
 ```bash npm2yarn copy
 npm install @mastra/memory@latest @mastra/libsql@latest
 ```
 
-```typescript {2-3, 10-14} filename="src/mastra/agents/test-agent.ts" showLineNumbers copy
+### Storage providers
+
+Mastra supports multiple storage providers. Popular options include:
+
+- [LibSQL](../../reference/storage/libsql.mdx)
+- [PostgreSQL](../../reference/storage/postgresql.mdx)
+- [Cloudflare D1](../../reference/storage/cloudflare-d1.mdx)
+
+<Callout type="warning">
+`LibSQLStore` works well for local development and when deploying to [Mastra Cloud](../mastra-cloud/overview.mdx), but may not be supported by some [serverless platforms](../deployment/serverless-platforms/index.mdx) or [cloud providers](../deployment/cloud-providers/index.mdx).
+</Callout>
+
+### Shared storage
+
+Use shared storage for a simple, centralized setup across agents. Add the storage adapter to your main Mastra instance to make it available to all agents by default.
+
+```typescript {6-8} filename="src/mastra/index.ts" showLineNumbers copy
+import { Mastra } from "@mastra/core/mastra";
+import { LibSQLStore } from "@mastra/libsql";
+
+export const mastra = new Mastra({
+  // ..
+  storage: new LibSQLStore({
+    url: ":memory:"
+  }),
+});
+```
+
+### Dedicated storage
+
+Use dedicated storage when agents need to keep data separate, use different providers, or tailor storage requirements for specific users. Add the storage adapter directly to the agent’s `memory` configuration option.
+
+```typescript {7-10} filename="src/mastra/agents/memory-agent.ts" showLineNumbers copy
 import { Agent } from "@mastra/core/agent";
 import { Memory } from "@mastra/memory";
 import { LibSQLStore } from "@mastra/libsql";
-import { openai } from "@ai-sdk/openai";
 
-export const testAgent = new Agent({
-  name: "test-agent",
-  instructions: "You are a helpful assistant with memory.",
-  model: openai("gpt-4o"),
+export const memoryAgent = new Agent({
+  // ...
   memory: new Memory({
     storage: new LibSQLStore({
-      url: "file:../../memory.db"
+      url: "file:../../memory-agent.db"
     })
   })
 });
 ```
 
-This basic setup uses the default settings. Visit the [Memory documentation](../memory/overview.mdx) for more configuration info.
-
 ## Memory in agent calls
 
 When calling `.generate()` or `.stream()`, include a `memory` object with both `resource` and `thread` to enable memory.
@@ -45,10 +85,10 @@ When calling `.generate()` or `.stream()`, include a `memory` object with both `
 These fields tell the agent where to store and retrieve context, enabling persistent, thread-aware memory across interactions.
 
 ```typescript {3-4}
-const response = await testAgent.generate("Remember my favorite color is blue.", {
+const response = await memoryAgent.generate("Remember my favorite color is blue.", {
   memory: {
-    resource: "user_alice",
-    thread: "preferences_thread",
+    thread: "user-123",
+    resource: "test-123"
   }
 });
 ```
@@ -56,25 +96,22 @@ const response = await testAgent.generate("Remember my favorite color is blue.",
 To recall information stored in memory, call the agent with the same `resource` and `thread` values used in the original interaction.
 
 ```typescript {3-4}
-const response = await testAgent.generate("What's my favorite color?", {
+const response = await memoryAgent.generate("What's my favorite color?", {
   memory: {
-    resource: "user_alice",
-    thread: "preferences_thread",
+    thread: "user-123",
+    resource: "test-123"
   }
 });
 ```
 
-## Memory with `RuntimeContext`
+## Using `RuntimeContext`
 
-You can configure memory dynamically using [RuntimeContext](./runtime-context.mdx), just like `instructions`, `models`, and `tools`. This gives you fine-grained control over memory behavior. For example, you can select different memory systems per user, enable features conditionally, or adapt configurations across environments.
+Use `RuntimeContext` to access request-specific values. This lets you conditionally select different memory or storage configurations based on the context of the request.
 
-### Agent configuration
-
-```typescript {18-20} filename="src/mastra/agents/test-agent.ts" showLineNumbers copy
-import { Agent } from "@mastra/core/agent";
-import { Memory } from "@mastra/memory";
-import { LibSQLStore } from "@mastra/libsql";
-import { openai } from "@ai-sdk/openai";
+```typescript filename="src/mastra/agents/memory-agent.ts" showLineNumbers
+export type UserTier = {
+  "user-tier": "enterprise" | "pro";
+};
 
 const premiumMemory = new Memory({
  // ...
@@ -84,68 +121,14 @@ const standardMemory = new Memory({
   // ...
 });
 
-export const testAgent = new Agent({
-  name: "test-agent",
-  instructions: "You are a helpful assistant with tiered memory capabilities.",
-  model: openai("gpt-4o"),
-  memory: ({ runtimeContext }) => {
-    const userTier = runtimeContext.get("userTier");
-    return userTier === "premium" ? premiumMemory : standardMemory;
-  }
-});
-```
-
-### Agent usage
-
-Pass a configured `RuntimeContext` instance to an agent to enable conditional logic during execution. This allows the agent to adapt its behavior based on runtime values.
-
-```typescript {1,4,6, 13} showLineNumbers copy
-import { RuntimeContext } from "@mastra/core/runtime-context";
-
-const testAgent = mastra.getAgent("testAgent");
-const runtimeContext = new RuntimeContext();
-
-runtimeContext.set("userTier", "premium");
-
-const response = await testAgent.generate("Remember my favorite color is blue.", {
-  memory: {
-    resource: "user_alice",
-    thread: { id: "preferences_thread" }
-  },
-  runtimeContext
-});
-```
-
-
-## Async memory configuration
-
-Memory can be configured asynchronously to support use cases like fetching user-specific settings from a database, validating access with Auth, or loading additional data from a remote service.
-
-```typescript {18, 22} filename="src/mastra/agents/test-agent.ts" showLineNumbers copy
-import { Agent } from "@mastra/core/agent";
-import { Memory } from "@mastra/memory";
-import { LibSQLStore } from "@mastra/libsql";
-import { openai } from "@ai-sdk/openai";
-
-const premiumMemory = new Memory({
- // ...
-});
-
-const standardMemory = new Memory({
+export const memoryAgent = new Agent({
   // ...
-});
-
-export const testAgent = new Agent({
-  name: "test-agent",
-  instructions: "You are a helpful assistant with tiered memory capabilities.",
-  model: openai("gpt-4o"),
-  memory: async ({ runtimeContext }) => {
-    const userId = runtimeContext.get("userId");
-
-    // Example database lookup using `userId`
-    const userTier = await query(`SELECT user_tier FROM users WHERE userId = $1`, [userId]);
+  memory: ({ runtimeContext }) => {
+    const userTier = runtimeContext.get("user-tier") as UserTier["user-tier"];
 
-    return userTier === "premium" ? premiumMemory : standardMemory;
+    return userTier === "enterprise"
+      ? premiumMemory
+      : standardMemory;
   }
 });
 ```
@@ -155,3 +138,4 @@ export const testAgent = new Agent({
 - [Working Memory](../memory/working-memory.mdx)
 - [Semantic Recall](../memory/semantic-recall.mdx)
 - [Threads and Resources](../memory/threads-and-resources.mdx)
+- [Runtime Context](../server-db/runtime-context.mdx)

package/.docs/raw/agents/guardrails.mdx

@@ -20,7 +20,7 @@ Use processors for content moderation, prompt injection prevention, response san
 
 ## Adding processors to an agent
 
-Import and instantiate the relevant processor class, and pass it to your agent’s configuration using either the `inputProcessors` or `outputProcessors` parameter:
+Import and instantiate the relevant processor class, and pass it to your agent’s configuration using either the `inputProcessors` or `outputProcessors` option:
 
 ```typescript {3,9-17} filename="src/mastra/agents/moderated-agent.ts" showLineNumbers copy
 import { openai } from "@ai-sdk/openai";

package/.docs/raw/agents/networks.mdx

@@ -60,9 +60,12 @@ const agentStep1 = createStep({
   }),
   execute: async ({ inputData }) => {
     const resp = await agent1.generate(inputData.city, {
-      output: z.object({
-        text: z.string(),
-      }),
+      structuredOutput: {
+        schema: z.object({
+          text: z.string(),
+        })
+      },
+      maxSteps: 1
     });
 
     return { text: resp.object.text };
@@ -80,9 +83,12 @@ const agentStep2 = createStep({
   }),
   execute: async ({ inputData }) => {
     const resp = await agent2.generate(inputData.text, {
-      output: z.object({
-        text: z.string(),
-      }),
+      structuredOutput: {
+        schema: z.object({
+          text: z.string(),
+        })
+      },
+      maxSteps: 1
     });
 
     return { text: resp.object.text };

package/.docs/raw/agents/overview.mdx

@@ -34,7 +34,7 @@ Mastra's model router auto-detects environment variables for your chosen provide
 OPENAI_API_KEY=<your-api-key>
 ```
 
-> Mastra supports more than 600 models. Choose from the full list [here](../getting-started/model-providers.mdx).
+> Mastra supports more than 600 models. Choose from the full list [here](/models).
 
 ### Create an agent
 
@@ -245,10 +245,13 @@ const response = await testAgent.generate(
     }
   ],
   {
-    output: z.object({
-      summary: z.string(),
-      keywords: z.array(z.string())
-    })
+    structuredOutput: {
+      schema: z.object({
+        summary: z.string(),
+        keywords: z.array(z.string())
+      })
+    },
+    maxSteps: 1
   }
 );
 
@@ -279,10 +282,6 @@ const response = await testAgent.generate([
 console.log(response.text);
 ```
 
-## Multi-step tool use
-
-Agents can be enhanced with tools, functions that extend their capabilities beyond text generation. Tools allow agents to perform calculations, access external systems, and process data. Agents not only decide whether to call tools they're given, they determine the parameters that should be given to that tool.
-
 For a detailed guide to creating and configuring tools, see the [Tools Overview](../tools-mcp/overview.mdx) page.
 
 ### Using `maxSteps`
@@ -311,6 +310,42 @@ const response = await testAgent.generate("Help me organize my day", {
 });
 ```
 
+## Using tools
+
+Agents can use tools to go beyond language generation, enabling structured interactions with external APIs and services. Tools allow agents to access data and perform clearly defined operations in a reliable, repeatable way.
+
+```typescript filename="src/mastra/agents/test-agent.ts" showLineNumbers
+export const testAgent = new Agent({
+  // ...
+  tools: { testTool }
+});
+```
+
+> See [Using Tools](./using-tools.mdx) for more information.
+
+## Using `RuntimeContext`
+
+Use `RuntimeContext` to access request-specific values. This lets you conditionally adjust behavior based on the context of the request.
+
+```typescript filename="src/mastra/agents/test-agent.ts" showLineNumbers
+export type UserTier = {
+  "user-tier": "enterprise" | "pro";
+};
+
+export const testAgent = new Agent({
+  // ...
+  model: ({ runtimeContext }) => {
+    const userTier = runtimeContext.get("user-tier") as UserTier["user-tier"];
+
+    return userTier === "enterprise"
+      ? openai("gpt-4o-mini")
+      : openai("gpt-4.1-nano");
+  }
+});
+```
+
+> See [Runtime Context](../server-db/runtime-context.mdx) for more information.
+
 ## Testing agents locally
 There are two ways to run and test agents.
 
@@ -350,7 +385,7 @@ npx tsx src/test-agent.ts
 
 ## Related
 
+- [Using Tools](./using-tools.mdx)
 - [Agent Memory](./agent-memory.mdx)
-- [Dynamic Agents](./dynamic-agents.mdx)
-- [Agent Tools and MCP](./using-tools-and-mcp.mdx)
+- [Runtime Context](../../examples/agents/runtime-context.mdx)
 - [Calling Agents](../../examples/agents/calling-agents.mdx)

package/.docs/raw/agents/using-tools.mdx

@@ -0,0 +1,95 @@
+---
+title: "Using Tools | Agents | Mastra Docs"
+description: Learn how to create tools and add them to agents to extend capabilities beyond text generation.
+---
+
+# Using Tools
+
+Agents use tools to call APIs, query databases, or run custom functions from your codebase. [Tools](../tools-mcp/overview.mdx) give agents capabilities beyond language generation by providing structured access to data and performing clearly defined operations. You can also load tools from remote [MCP servers](../tools-mcp/mcp-overview.mdx) to expand an agent’s capabilities.
+
+## When to use tools
+
+Use tools when an agent needs additional context or information from remote resources, or when it needs to run code that performs a specific operation. This includes tasks a model can't reliably handle on its own, such as fetching live data or returning consistent, well defined outputs.
+
+## Creating a tool
+
+This example shows how to create a tool that fetches weather data from an API. When the agent calls the tool, it provides the required input as defined by the tool’s `inputSchema`. The tool accesses this data through its `context` argument, which in this example includes the `location` used in the weather API query.
+
+```typescript {14,16} filename="src/mastra/tools/weather-tool.ts" showLineNumbers copy
+import { createTool } from "@mastra/core/tools";
+import { z } from "zod";
+
+export const weatherTool = createTool({
+  id: "weather-tool",
+  description: "Fetches weather for a location",
+  inputSchema: z.object({
+    location: z.string()
+  }),
+  outputSchema: z.object({
+    weather: z.string()
+  }),
+  execute: async ({ context }) => {
+    const { location } = context;
+
+    const response = await fetch(`https://wttr.in/${location}?format=3`);
+    const weather = await response.text();
+
+    return { weather };
+  }
+});
+```
+
+## Adding tools to an agent
+
+To make a tool available to an agent, add it to the `tools` option and reference it by name in the agent’s instructions.
+
+```typescript {9,11} filename="src/mastra/agents/weather-agent.ts" showLineNumbers copy
+import { openai } from "@ai-sdk/openai";
+import { Agent } from "@mastra/core/agent";
+import { weatherTool } from "../tools/weather-tool";
+
+export const weatherAgent = new Agent({
+  name: "weather-agent",
+  instructions: `
+      You are a helpful weather assistant.
+      Use the weatherTool to fetch current weather data.`,
+  model: openai("gpt-4o-mini"),
+  tools: { weatherTool }
+});
+```
+
+## Calling an agent
+
+The agent uses the tool’s `inputSchema` to infer what data the tool expects. In this case, it extracts `London` as the `location` from the message and makes it available to the tool’s context.
+
+```typescript {5} filename="src/test-tool.ts" showLineNumbers copy
+import { mastra } from "./mastra";
+
+const agent = mastra.getAgent("weatherAgent");
+
+const result = await agent.generate("What's the weather in London?");
+```
+
+## Using multiple tools
+
+An agent can use multiple tools to handle more complex tasks by delegating specific parts to individual tools. The agent decides which tools to use based on the user’s message, the agent’s instructions, and the tool descriptions and schemas.
+
+When multiple tools are available, the agent may choose to use one, several, or none, depending on what’s needed to answer the query.
+
+```typescript {6} filename="src/mastra/agents/weather-agent.ts" showLineNumbers copy
+import { weatherTool } from "../tools/weather-tool";
+import { activitiesTool } from "../tools/activities-tool";
+
+export const weatherAgent = new Agent({
+  // ..
+  tools: { weatherTool, activitiesTool }
+});
+```
+
+
+## Related
+
+- [Tools Overview](../tools-mcp/overview.mdx)
+- [Agent Memory](./agent-memory.mdx)
+- [Runtime Context](./runtime-context.mdx)
+- [Calling Agents](../../examples/agents/calling-agents.mdx)

package/.docs/raw/deployment/overview.mdx

@@ -7,6 +7,15 @@ description: Learn about different deployment options for your Mastra applicatio
 
 Mastra offers multiple deployment options to suit your application's needs, from fully-managed solutions to self-hosted options, and web framework integrations. This guide will help you understand the available deployment paths and choose the right one for your project.
 
+## Choosing a Deployment Option
+
+| Option                   | Best For                                                      | Key Benefits                                                    |
+| ------------------------ | ------------------------------------------------------------- | -------------------------------------------------------------- |
+| **Mastra Cloud**         | Teams wanting to ship quickly without infrastructure concerns | Fully-managed, automatic scaling, built-in observability       |
+| **Framework Deployment** | Teams already using Next.js, Astro etc                          | Simplify deployment with a unified codebase for frontend and backend  |
+| **Server Deployment**    | Teams needing maximum control and customization               | Full control, custom middleware, integrate with existing apps  |
+| **Serverless Platforms** | Teams already using Vercel, Netlify, or Cloudflare             | Platform integration, simplified deployment, automatic scaling  |
+
 ## Deployment Options
 
 ### Runtime support
@@ -71,14 +80,3 @@ Once your Mastra application is deployed, you'll need to configure your client t
 - Support for streaming responses
 
 [Client configuration guide →](../server-db/mastra-client.mdx)
-
-## Choosing a Deployment Option
-
-| Option                   | Best For                                                      | Key Benefits                                                    |
-| ------------------------ | ------------------------------------------------------------- | -------------------------------------------------------------- |
-| **Mastra Cloud**         | Teams wanting to ship quickly without infrastructure concerns | Fully-managed, automatic scaling, built-in observability       |
-| **Framework Deployment** | Teams already using Next.js, Astro etc                          | Simplify deployment with a unified codebase for frontend and backend  |
-| **Server Deployment**    | Teams needing maximum control and customization               | Full control, custom middleware, integrate with existing apps  |
-| **Serverless Platforms** | Teams already using Vercel, Netlify, or Cloudflare             | Platform integration, simplified deployment, automatic scaling  |
-
-

package/.docs/raw/frameworks/agentic-uis/ai-sdk.mdx

@@ -33,7 +33,7 @@ export const weatherAgent = new Agent({
 });
 ```
 
-> See [Model Providers](/docs/getting-started/model-providers) and [Model Capabilities](/docs/getting-started/model-capability) for more information.
+> See [Model Providers](/models) and [Model Capabilities](/models) for more information.
 
 ## React Hooks
 
@@ -181,9 +181,12 @@ export async function POST(req: Request) {
   const body = await req.json();
   const myAgent = mastra.getAgent("weatherAgent");
   const stream = await myAgent.stream(body, {
-    output: z.object({
-      weather: z.string()
-    })
+    structuredOutput: {
+      schema: z.object({
+        weather: z.string()
+      })
+    },
+    maxSteps: 1
   });
 
   return stream.toTextStreamResponse();