@mastra/mcp-docs-server 1.2.1-alpha.2 → 1.2.1-alpha.5

package/.docs/docs/build-with-ai/mcp-docs-server.md

@@ -1,238 +0,0 @@
-# Mastra docs server
-
-The `@mastra/mcp-docs-server` package provides direct access to Mastra’s full documentation via the [Model Context Protocol (MCP)](https://modelcontextprotocol.io/docs/getting-started/intro). It works with Cursor, Windsurf, Cline, Claude Code, VS Code, Codex or any tool that supports MCP.
-
-These tools are designed to help agents retrieve precise, task-specific information — whether you're adding a feature to an agent, scaffolding a new project, or exploring how something works.
-
-In this guide you'll learn how to add Mastra's MCP server to your AI tooling.
-
-[YouTube video player](https://www.youtube-nocookie.com/embed/vciV57lF0og)
-
-## Installation
-
-### create-mastra
-
-During the interactive [create-mastra](https://mastra.ai/reference/cli/create-mastra) wizard, choose one of your tools in the MCP step.
-
-### Manual setup
-
-If there are no specific instructions for your tool below, you may be able to add the MCP server with this common JSON configuration anyways.
-
-```json
-{
-  "mcpServers": {
-    "mastra": {
-      "type": "stdio",
-      "command": "npx",
-      "args": ["-y", "@mastra/mcp-docs-server@latest"]
-    }
-  }
-}
-```
-
-### Claude Code CLI
-
-Install using the terminal command:
-
-```bash
-claude mcp add --scope project mastra -- npx -y @mastra/mcp-docs-server@latest
-```
-
-This creates a project-scoped `.mcp.json` file if one doesn't already exist. You can use the same command when using Claude Code as a [Visual Studio Code extension](https://code.claude.com/docs/en/vs-code#connect-to-external-tools-with-mcp).
-
-[More info on using MCP servers with Claude Code](https://docs.claude.com/en/docs/claude-code/mcp)
-
-### OpenAI Codex CLI
-
-1. Register it from the terminal:
-
-   ```bash
-   codex mcp add mastra-docs -- npx -y @mastra/mcp-docs-server@latest
-   ```
-
-2. Run `codex mcp list` to confirm the server shows as `enabled`.
-
-[More info on using MCP servers with OpenAI Codex](https://developers.openai.com/codex/mcp)
-
-### Cursor
-
-Install by selecting the button below:
-
-[![Install MCP Server](https://cursor.com/deeplink/mcp-install-light.svg)](cursor://anysphere.cursor-deeplink/mcp/install?name=mastra\&config=eyJjb21tYW5kIjoibnB4IC15IEBtYXN0cmEvbWNwLWRvY3Mtc2VydmVyIn0%3D)
-
-If you followed the automatic installation, you'll see a popup when you open cursor in the bottom left corner to prompt you to enable the Mastra Docs MCP Server.
-
-![Popup inside Cursor showing: \"New MCP server detected: mastra\". The user can \"Skip\" or \"Enable\" it as an action.](/assets/images/enable-mastra-docs-cursor-cd5872abdc36c0e10951a59a47f25e12.png)
-
-[More info on using MCP servers with Cursor](https://cursor.com/de/docs/context/mcp)
-
-### Antigravity
-
-Google Antigravity is an agent-first development platform that supports MCP servers for accessing external documentation, APIs, and project context.
-
-1. Open your Antigravity MCP configuration file:
-
-   - Click on **Agent session** and select the **“…” dropdown** at the top of the editor’s side panel, then select **MCP Servers** to access the **MCP Store**.
-   - You can access it through the MCP Store interface in Antigravity
-
-   ![The Antigravity MCP store. At the top is a search bar and below a list of available MCP servers. On the very top right is a dropdown menu.](/assets/images/antigravity_mcp_server-689ea495d9c7139cc431f1f1b9827f9b.png)
-
-2. To add a custom MCP server, select **Manage MCP Servers** at the top of the MCP Store and select **View raw config** in the main tab.
-
-   ![The Antigravity MCP store showing the Manage MCP Servers option and the View raw config button.](/assets/images/antigravity_managed_mcp-b661e8c04b3219000f8d842e5eb26a1a.png)
-
-3. Add the Mastra MCP server configuration:
-
-   ```json
-   {
-     "mcpServers": {
-       "mastra-docs": {
-         "command": "npx",
-         "args": ["-y", "@mastra/mcp-docs-server"]
-       }
-     }
-   }
-   ```
-
-4. Save the configuration and restart Antigravity
-
-   ![The UI shows that the MCP server is enabled. You can also toggle individual tools.](/assets/images/antigravity_final_interface_mcp-7fa132dbe76cdee9f61136a26d6e6615.png)
-
-Once configured, the Mastra MCP server exposes the following to Antigravity agents:
-
-- Indexed documentation and API schemas for Mastra, enabling programmatic retrieval of relevant context during code generation
-- Access to example code snippets and usage patterns stored in Mastra Docs
-- Structured data for error handling and debugging references in the editor
-- Metadata about current Mastra project patterns for code suggestion and completion
-
-The MCP server will appear in Antigravity's MCP Store, where you can manage its connection status and authentication if needed.
-
-[More info on using MCP servers with Antigravity](https://antigravity.google)
-
-### Visual Studio Code
-
-1. Create a `.vscode/mcp.json` file in your workspace
-
-2. Insert the following configuration:
-
-   ```json
-   {
-     "servers": {
-       "mastra": {
-         "type": "stdio",
-         "command": "npx",
-         "args": ["-y", "@mastra/mcp-docs-server@latest"]
-       }
-     }
-   }
-   ```
-
-Once you installed the MCP server, you can use it like so:
-
-1. Open VSCode settings.
-
-2. Navigate to MCP settings.
-
-3. Click "enable" on the Chat > MCP option.
-
-   ![Entry in VSCode\'s settings page. The option is called \"Chat \> MCP: Enabled (Preview)\". The description says: \"Enables integration with Model Context Protocol servers to provide additional tools and functionality.\"](/assets/images/vscode-mcp-setting-8d1eb4f3df1e33606503f8c5e937e9e3.png)
-
-MCP only works in Agent mode in VSCode. Once you are in agent mode, open the `mcp.json` file and select the "start" button. Note that the "start" button will only appear if the `.vscode` folder containing `mcp.json` is in your workspace root, or the highest level of the in-editor file explorer.
-
-![A screenshot of the mcp.json file showing the start button in the editor](/assets/images/vscode-start-mcp-26480d86080c4907cb497a325de106a4.png)
-
-After starting the MCP server, select the tools button in the Copilot pane to see available tools.
-
-![Tools page of VSCode to see available tools](/assets/images/vscode-mcp-running-d92d6ed234d1148093dc804b0ead3515.png)
-
-[More info on using MCP servers with Visual Studio Code](https://code.visualstudio.com/docs/copilot/customization/mcp-servers)
-
-### Windsurf
-
-1. Open `~/.codeium/windsurf/mcp_config.json` in your editor
-
-2. Insert the following configuration:
-
-   ```json
-   {
-     "mcpServers": {
-       "mastra": {
-         "command": "npx",
-         "args": ["-y", "@mastra/mcp-docs-server@latest"]
-       }
-     }
-   }
-   ```
-
-3. Save the configuration and restart Windsurf
-
-[More info on using MCP servers with Windsurf](https://docs.windsurf.com/windsurf/cascade/mcp#mcp-config-json)
-
-### OpenCode
-
-You can define MCP servers in your [OpenCode configuration](https://opencode.ai/docs/config/) under `mcp`. Create an `opencode.jsonc` file in your project root with the following content:
-
-```json
-{
-  "$schema": "https://opencode.ai/config.json",
-  "mcp": {
-    "mastra": {
-      "type": "local",
-      "command": ["npx", "-y", "@mastra/mcp-docs-server@latest"],
-      "enabled": true
-    }
-  }
-}
-```
-
-[More info on using MCP servers with OpenCode](https://opencode.ai/docs/mcp-servers)
-
-### Zed
-
-1. Open `~/.config/zed/settings.json` in your editor
-2. Insert the following configuration:
-
-```json
-{
-  "context_servers": {
-    "Mastra": {
-      "command": "npx",
-      "args": ["-y", "@mastra/mcp-docs-server@latest"]
-    }
-  }
-}
-```
-
-## Usage
-
-Once configured, you can ask your AI tool questions about Mastra or instruct it to take actions. For these steps, it'll take the up-to-date information from Mastra's MCP server.
-
-**Add features:**
-
-- "Add evals to my agent and write tests"
-- "Write me a workflow that does the following `[task]`"
-- "Make a new tool that allows my agent to access `[3rd party API]`"
-
-**Ask about integrations:**
-
-- "Does Mastra work with the AI SDK? How can I use it in my `[React/Svelte/etc]` project?"
-- "Does Mastra support `[provider]` speech and voice APIs? Show me an example in my code of how I can use it."
-
-**Debug or update existing code:**
-
-- "I'm running into a bug with agent memory, have there been any related changes or bug fixes recently?"
-- "How does working memory behave in Mastra and how can I use it to do `[task]`? It doesn't seem to work the way I expect."
-- "I saw there are new workflow features, explain them to me and then update `[workflow]` to use them."
-
-### Troubleshooting
-
-1. **Server Not Starting**
-
-   - Ensure [npx](https://docs.npmjs.com/cli/v11/commands/npx) is installed and working.
-   - Check for conflicting MCP servers.
-   - Verify your configuration file syntax.
-
-2. **Tool Calls Failing**
-
-   - Restart the MCP server and/or your IDE.
-   - Update to the latest version of your IDE.

package/.docs/docs/build-with-ai/skills.md

@@ -1,63 +0,0 @@
-# Mastra skills
-
-Mastra Skills are folders of instructions, scripts, and resources that agents can discover and use to gain Mastra knowledge. They contain setup instructions, best practices, and methods to fetch up-to-date information from Mastra's documentation.
-
-## Installation
-
-To install all available Mastra skills, run the following command:
-
-**npm**:
-
-```bash
-npx skills add mastra-ai/skills
-```
-
-**pnpm**:
-
-```bash
-pnpm dlx skills add mastra-ai/skills
-```
-
-**Yarn**:
-
-```bash
-yarn dlx skills add mastra-ai/skills
-```
-
-**Bun**:
-
-```bash
-bun x skills add mastra-ai/skills
-```
-
-Mastra skills work with any coding agent that supports the [Skills standard](https://agentskills.io/), including Claude Code, Cursor, Codex, OpenCode, and others.
-
-They're also available on [GitHub](https://github.com/mastra-ai/skills).
-
-## Update skill
-
-To update to the latest version of the Mastra skill, run:
-
-**npm**:
-
-```bash
-npx skills update mastra
-```
-
-**pnpm**:
-
-```bash
-pnpm dlx skills update mastra
-```
-
-**Yarn**:
-
-```bash
-yarn dlx skills update mastra
-```
-
-**Bun**:
-
-```bash
-bun x skills update mastra
-```

package/.docs/docs/streaming/background-task-streaming.md

@@ -1,80 +0,0 @@
-# Background task streaming
-
-**Added in:** `@mastra/core@1.29.0`
-
-`mastra.backgroundTaskManager.stream()` returns a `ReadableStream` of [background task](https://mastra.ai/docs/agents/background-tasks) lifecycle events. Use it to monitor running tasks across the system, for example to drive a status dashboard, surface progress in your own UI, or pipe events into an SSE response.
-
-The stream emits the same chunk types that appear inside `Agent.streamUntilIdle()` (`background-task-running`, `background-task-output`, `background-task-completed`, `background-task-failed`, `background-task-cancelled`). See [background task chunks](https://mastra.ai/reference/streaming/ChunkType) for the full payload shapes.
-
-> **Note:** Background tasks must be [enabled on the Mastra instance](https://mastra.ai/reference/configuration) before `backgroundTaskManager` is available. When disabled, `mastra.backgroundTaskManager` is `undefined`.
-
-## Subscribe to all task events
-
-Calling `stream()` with no filter returns a stream of every task event in the system. On connection, the stream emits a snapshot of all currently running tasks, then forwards live events as they happen.
-
-```typescript
-const bgManager = mastra.backgroundTaskManager
-if (!bgManager) throw new Error('Background tasks are not enabled')
-
-const controller = new AbortController()
-const stream = bgManager.stream({ abortSignal: controller.signal })
-
-for await (const chunk of stream) {
-  switch (chunk.type) {
-    case 'background-task-running':
-      console.log('started', chunk.payload.taskId, chunk.payload.toolName)
-      break
-    case 'background-task-completed':
-      console.log('done', chunk.payload.taskId, chunk.payload.result)
-      break
-    case 'background-task-failed':
-      console.error('failed', chunk.payload.taskId, chunk.payload.error)
-      break
-  }
-}
-```
-
-The stream stays open until the caller's `AbortSignal` fires. Always pass an `abortSignal` so you can disconnect cleanly.
-
-## Filter the stream
-
-Pass any combination of filter options to narrow the events you receive. Filters apply to both the initial snapshot and the live event subscription.
-
-```typescript
-const stream = bgManager.stream({
-  agentId: 'researcher',
-  threadId: 't1',
-  resourceId: 'u1',
-  abortSignal: controller.signal,
-})
-```
-
-| Filter        | Description                                         |
-| ------------- | --------------------------------------------------- |
-| `agentId`     | Only events from tasks dispatched by this agent     |
-| `runId`       | Only events from this specific agent run            |
-| `threadId`    | Only events from tasks scoped to this memory thread |
-| `resourceId`  | Only events from tasks scoped to this resource      |
-| `taskId`      | Only events for a single task                       |
-| `abortSignal` | Closes the stream when the signal aborts            |
-
-## Look up task state directly
-
-For one-off lookups instead of a live stream, use `getTask` and `listTasks`:
-
-```typescript
-const task = await mastra.backgroundTaskManager?.getTask(taskId)
-const { tasks, total } = await mastra.backgroundTaskManager?.listTasks({
-  status: 'running',
-  agentId: 'researcher',
-})
-```
-
-These read from storage rather than the pubsub stream, so they're suitable for paginated lists and detail views.
-
-## Related
-
-- [Background tasks](https://mastra.ai/docs/agents/background-tasks)
-- [`Agent.streamUntilIdle()` reference](https://mastra.ai/reference/streaming/agents/streamUntilIdle)
-- [Background task chunks](https://mastra.ai/reference/streaming/ChunkType)
-- [backgroundTasks configuration reference](https://mastra.ai/reference/configuration)

package/.docs/docs/streaming/events.md

@@ -1,148 +0,0 @@
-# Streaming events
-
-Streaming from agents or workflows provides real-time visibility into either the LLM’s output or the status of a workflow run. This feedback can be passed directly to the user, or used within applications to handle workflow status more effectively, creating a smoother and more responsive experience.
-
-Events emitted from agents or workflows represent different stages of generation and execution, such as when a run starts, when text is produced, or when a tool is invoked.
-
-## Event types
-
-Below is a complete list of events emitted from `.stream()`. Depending on whether you’re streaming from an **agent** or a **workflow**, only a subset of these events will occur:
-
-- **start**: Marks the beginning of an agent or workflow run.
-- **step-start**: Indicates a workflow step has begun execution.
-- **text-delta**: Incremental text chunks as they're generated by the LLM.
-- **tool-call**: When the agent decides to use a tool, including the tool name and arguments.
-- **tool-result**: The result returned from tool execution.
-- **step-finish**: Confirms that a specific step has fully finalized, and may include metadata like the finish reason for that step.
-- **finish**: When the agent or workflow completes, including usage statistics.
-
-## Network event types
-
-When using `agent.network()` for multi-agent collaboration, additional event types are emitted to track the orchestration flow:
-
-- **routing-agent-start**: The routing agent begins analyzing the task to decide which primitive (agent/workflow/tool) to delegate to.
-- **routing-agent-text-delta**: Incremental text as the routing agent processes the response from the selected primitive.
-- **routing-agent-end**: The routing agent completes its selection, including the selected primitive and reason for selection.
-- **agent-execution-start**: A delegated agent begins execution.
-- **agent-execution-end**: A delegated agent completes execution.
-- **agent-execution-event-\***: Events from the delegated agent's execution (e.g., `agent-execution-event-text-delta`).
-- **workflow-execution-start**: A delegated workflow begins execution.
-- **workflow-execution-end**: A delegated workflow completes execution.
-- **workflow-execution-event-\***: Events from the delegated workflow's execution.
-- **tool-execution-start**: A delegated tool begins execution.
-- **tool-execution-end**: A delegated tool completes execution.
-- **network-execution-event-step-finish**: A network iteration step completes.
-- **network-execution-event-finish**: The entire network execution completes.
-
-## Inspecting agent streams
-
-Iterate over the `stream` with a `for await` loop to inspect all emitted event chunks.
-
-```typescript
-const testAgent = mastra.getAgent('testAgent')
-
-const stream = await testAgent.stream([{ role: 'user', content: 'Help me organize my day' }])
-
-for await (const chunk of stream) {
-  console.log(chunk)
-}
-```
-
-> **Info:** Visit [Agent.stream()](https://mastra.ai/reference/streaming/agents/stream) for more information.
-
-### Example agent output
-
-Below is an example of events that may be emitted. Each event always includes a `type` and can include additional fields like `from` and `payload`.
-
-```typescript
-{
-  type: 'start',
-  from: 'AGENT',
-  // ..
-}
-{
-  type: 'step-start',
-  from: 'AGENT',
-  payload: {
-    messageId: 'msg-cdUrkirvXw8A6oE4t5lzDuxi',
-    // ...
-  }
-}
-{
-  type: 'tool-call',
-  from: 'AGENT',
-  payload: {
-    toolCallId: 'call_jbhi3s1qvR6Aqt9axCfTBMsA',
-    toolName: 'testTool'
-    // ..
-  }
-}
-```
-
-## Inspecting workflow streams
-
-Iterate over the `stream` with a `for await` loop to inspect all emitted event chunks.
-
-```typescript
-const testWorkflow = mastra.getWorkflow('testWorkflow')
-
-const run = await testWorkflow.createRun()
-
-const stream = await run.stream({
-  inputData: {
-    value: 'initial data',
-  },
-})
-
-for await (const chunk of stream) {
-  console.log(chunk)
-}
-```
-
-### Example workflow output
-
-Below is an example of events that may be emitted. Each event always includes a `type` and can include additional fields like `from` and `payload`.
-
-```typescript
-{
-  type: 'workflow-start',
-  runId: '221333ed-d9ee-4737-922b-4ab4d9de73e6',
-  from: 'WORKFLOW',
-  // ...
-}
-{
-  type: 'workflow-step-start',
-  runId: '221333ed-d9ee-4737-922b-4ab4d9de73e6',
-  from: 'WORKFLOW',
-  payload: {
-    stepName: 'step-1',
-    args: { value: 'initial data' },
-    stepCallId: '9e8c5217-490b-4fe7-8c31-6e2353a3fc98',
-    startedAt: 1755269732792,
-    status: 'running'
-  }
-}
-```
-
-### Foreach progress events
-
-When a workflow uses `.foreach()`, each iteration emits a `workflow-step-progress` event. You can use these to track real-time progress:
-
-```typescript
-for await (const chunk of stream) {
-  if (chunk.type === 'workflow-step-progress') {
-    console.log(
-      `${chunk.payload.id}: ${chunk.payload.completedCount}/${chunk.payload.totalCount} — ${chunk.payload.iterationStatus}`,
-    )
-  }
-}
-```
-
-Each progress event includes:
-
-- **`id`**: The step ID of the foreach step
-- **`completedCount`**: Number of iterations completed so far
-- **`totalCount`**: Total number of iterations
-- **`currentIndex`**: Index of the iteration that completed
-- **`iterationStatus`**: Status of the iteration (`success`, `failed`, or `suspended`)
-- **`iterationOutput`**: Output of the iteration (when successful)

package/.docs/docs/streaming/overview.md

@@ -1,136 +0,0 @@
-# Streaming overview
-
-Mastra supports real-time, incremental responses from agents and workflows, allowing users to see output as it’s generated instead of waiting for completion. This is useful for chat, long-form content, multi-step workflows, or any scenario where immediate feedback matters.
-
-## Getting started
-
-Mastra's streaming API adapts based on your model version:
-
-- **`.stream()`**: For V2 models, supports **AI SDK v5** and later (`LanguageModelV2`).
-- **`.streamLegacy()`**: For V1 models, supports **AI SDK v4** (`LanguageModelV1`).
-
-## Streaming with agents
-
-You can pass a single string for basic prompts, an array of strings when providing multiple pieces of context, or an array of message objects with `role` and `content` for precise control over roles and conversational flows.
-
-### Using `Agent.stream()`
-
-A `textStream` breaks the response into chunks as it's generated, allowing output to stream progressively instead of arriving all at once. Iterate over the `textStream` using a `for await` loop to inspect each stream chunk.
-
-```typescript
-const testAgent = mastra.getAgent('testAgent')
-
-const stream = await testAgent.stream([{ role: 'user', content: 'Help me organize my day' }])
-
-for await (const chunk of stream.textStream) {
-  process.stdout.write(chunk)
-}
-```
-
-> **Info:** Visit [Agent.stream()](https://mastra.ai/reference/streaming/agents/stream) for more information.
-
-> **Tip:** For agents that dispatch [background tasks](https://mastra.ai/docs/agents/background-tasks), use [`Agent.streamUntilIdle()`](https://mastra.ai/reference/streaming/agents/streamUntilIdle) to keep the stream open until those tasks complete and the agent has had a chance to respond to their results.
-
-### Output from `Agent.stream()`
-
-The output streams the generated response from the agent.
-
-```text
-Of course!
-To help you organize your day effectively, I need a bit more information.
-Here are some questions to consider:
-...
-```
-
-### Agent stream properties
-
-An agent stream provides access to various response properties:
-
-- **`stream.textStream`**: A readable stream that emits text chunks.
-- **`stream.text`**: Promise that resolves to the full text response.
-- **`stream.finishReason`**: The reason the agent stopped streaming.
-- **`stream.usage`**: Token usage information.
-
-### AI SDK v5+ Compatibility
-
-AI SDK v5 (and later) uses `LanguageModelV2` for the model providers. If you are getting an error that you are using an AI SDK v4 model you will need to upgrade your model package to the next major version.
-
-For integration with AI SDK v5+, use the `toAISdkV5Stream()` utility from `@mastra/ai-sdk` to convert Mastra streams to AI SDK-compatible format:
-
-```typescript
-import { toAISdkV5Stream } from '@mastra/ai-sdk'
-
-const testAgent = mastra.getAgent('testAgent')
-
-const stream = await testAgent.stream([{ role: 'user', content: 'Help me organize my day' }])
-
-// Convert to AI SDK v5+ compatible stream
-const aiSDKStream = toAISdkV5Stream(stream, { from: 'agent' })
-```
-
-For converting messages to AI SDK v5+ format, use the `toAISdkV5Messages()` utility from `@mastra/ai-sdk/ui`:
-
-```typescript
-import { toAISdkV5Messages } from '@mastra/ai-sdk/ui'
-
-const messages = [{ role: 'user', content: 'Hello' }]
-const aiSDKMessages = toAISdkV5Messages(messages)
-```
-
-## Streaming with workflows
-
-Streaming from a workflow returns a sequence of structured events describing the run lifecycle, rather than incremental text chunks. This event-based format makes it possible to track and respond to workflow progress in real time once a run is created using `.createRun()`.
-
-### Using `Run.stream()`
-
-The `stream()` method returns a `ReadableStream` of events directly.
-
-```typescript
-const run = await testWorkflow.createRun()
-
-const stream = await run.stream({
-  inputData: {
-    value: 'initial data',
-  },
-})
-
-for await (const chunk of stream) {
-  console.log(chunk)
-}
-```
-
-> **Info:** Visit [Run.stream()](https://mastra.ai/reference/streaming/workflows/stream) for more information.
-
-### Output from `Run.stream()`
-
-The event structure includes `runId` and `from` at the top level, making it easier to identify and track workflow runs without digging into the payload.
-
-```typescript
-{
-  type: 'workflow-start',
-  runId: '1eeaf01a-d2bf-4e3f-8d1b-027795ccd3df',
-  from: 'WORKFLOW',
-  payload: {
-    stepName: 'step-1',
-    args: { value: 'initial data' },
-    stepCallId: '8e15e618-be0e-4215-a5d6-08e58c152068',
-    startedAt: 1755121710066,
-    status: 'running'
-  }
-}
-```
-
-### Workflow stream properties
-
-A workflow stream provides access to various response properties:
-
-- **`stream.status`**: The status of the workflow run.
-- **`stream.result`**: The result of the workflow run.
-- **`stream.usage`**: The total token usage of the workflow run.
-
-## Related
-
-- [Streaming events](https://mastra.ai/docs/streaming/events)
-- [Background tasks](https://mastra.ai/docs/agents/background-tasks)
-- [Using Agents](https://mastra.ai/docs/agents/overview)
-- [Workflows overview](https://mastra.ai/docs/workflows/overview)