@mastra/mcp-docs-server 0.13.1-alpha.0 → 0.13.1-alpha.2

package/.docs/raw/workflows/control-flow.mdx

@@ -14,27 +14,16 @@ When you build a workflow, you typically break down operations into smaller task
 
 Chain steps to execute in sequence using `.then()`:
 
-```typescript {18,19,20} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {8-9} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const step1 = createStep({...});
 const step2 = createStep({...});
-const step3 = createStep({...});
-
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
+
+export const testWorkflow = createWorkflow({...})
   .then(step1)
   .then(step2)
-  .then(step3)
   .commit();
 ```
 
@@ -42,55 +31,34 @@ export const testWorkflow = createWorkflow({
 
 Execute steps in parallel using `.parallel()`:
 
-
-```typescript {18} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {8} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const step1 = createStep({...});
 const step2 = createStep({...});
-const step3 = createStep({...});
-
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
+
+export const testWorkflow = createWorkflow({...})
   .parallel([step1, step2])
-  .then(step3)
   .commit();
 ```
 
 This executes all steps in the array concurrently, then continues to the next step after all parallel steps complete.
 
+> See [Parallel Execution with Steps](/examples/workflows/parallel-steps) for more information.
+
 ## Branch
 
 Create conditional branches using `.branch()`:
 
-```typescript {19-22} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {8-11} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
-const step1 = createStep({...});
 const lessThanStep = createStep({...});
 const greaterThanStep = createStep({...});
 
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
-  .then(step1)
+export const testWorkflow = createWorkflow({...})
   .branch([
     [async ({ inputData: { some_value } }) => some_value <= 9, lessThanStep],
     [async ({ inputData: { some_value } }) => some_value >= 10, greaterThanStep]
@@ -100,6 +68,8 @@ export const testWorkflow = createWorkflow({
 
 Branch conditions are evaluated sequentially, but steps with matching conditions are executed in parallel.
 
+> See [Workflow with Conditional Branching](/examples/workflows/conditional-branching) for more information.
+
 ## Loops
 
 Workflows support two types of loops. When looping a step, or any step-compatible construct like a nested workflow, the initial `inputData` is sourced from the output of the previous step.
@@ -114,27 +84,14 @@ To ensure compatibility, the loop’s initial input must either:
 
 Executes a step repeatedly while a condition is true.
 
-```typescript {19} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
-const step1 = createStep({...});
 const counterStep = createStep({...});
-const finalStep = createStep({...});
-
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
-  .then(step1)
+
+export const testWorkflow = createWorkflow({...})
   .dowhile(counterStep, async ({ inputData: { number } }) => number < 10)
-  .then(finalStep)
   .commit();
 ```
 
@@ -142,62 +99,29 @@ export const testWorkflow = createWorkflow({
 
 Executes a step repeatedly until a condition becomes true.
 
-```typescript {19} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
-const step1 = createStep({...});
 const counterStep = createStep({...});
-const finalStep = createStep({...});
-
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
-  .then(step1)
+
+export const testWorkflow = createWorkflow({...})
   .dountil(counterStep, async ({ inputData: { number } }) => number > 10)
-  .then(finalStep)
   .commit();
 ```
 
 
 ### Foreach
 
-Sequentially executes the same step for each item in the `inputData` array.
-
-```typescript {27} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-const mapStep = createStep({
-  id: "map-step",
-  description: "Adds 100 on the input number",
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  }),
-  execute: async ({ inputData }) => {
-    const { number } = inputData;
-
-    return {
-      number: number + 100
-    };
-  }
-});
+Sequentially executes the same step for each item from the `inputSchema`.
+
+```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { createWorkflow, createStep } from "@mastra/core/workflows";
+import { z } from "zod";
 
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.array(z.object({ number: z.number() })),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
+const mapStep = createStep({...});
+
+export const testWorkflow = createWorkflow({...})
   .foreach(mapStep)
   .commit();
 ```
@@ -226,17 +150,13 @@ npx tsx src/test-workflow.ts
 
 Optionally, using `concurrency` allows you to execute steps in parallel with a limit on the number of concurrent executions.
 
-```typescript {11} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { createWorkflow, createStep } from "@mastra/core/workflows";
+import { z } from "zod";
+
 const mapStep = createStep({...})
 
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.array(z.object({ number: z.number() })),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
+export const testWorkflow = createWorkflow({...})
   .foreach(mapStep, { concurrency: 2 })
   .commit();
 ```
@@ -245,26 +165,15 @@ export const testWorkflow = createWorkflow({
 
 Workflows themselves can also be executed in parallel.
 
-```typescript {4,5,18} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+```typescript {4-5,8} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const workflow1 = createWorkflow({...});
 const workflow2 = createWorkflow({...});
-const finalStep = createStep({...});
-
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
+
+export const testWorkflow = createWorkflow({...})
   .parallel([workflow1, workflow2])
-  .then(finalStep)
   .commit();
 ```
 
@@ -275,35 +184,13 @@ Parallel steps receive previous step results as input. Their outputs are passed
 In the example below, `nestedWorkflow` is used as a step within `testWorkflow`. The `testWorkflow` uses `step1` whilst the `nestedWorkflow` composes `step2` and `step3`
 
 
-```typescript {5,29} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-const step1 = createStep({...});
-const step2 = createStep({...});
-const step3 = createStep({...});
-
-export const nestedWorkflow = createWorkflow({
-  id: "nested-workflow",
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
-  .then(step2)
-  .then(step3)
-  .commit();
+```typescript {4,7} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { createWorkflow, createStep } from "@mastra/core/workflows";
+import { z } from "zod";
 
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
-  .then(step1)
+export const nestedWorkflow = createWorkflow({...})
+
+export const testWorkflow = createWorkflow({...})
   .then(nestedWorkflow)
   .commit();
 ```
@@ -315,28 +202,15 @@ When using `.branch()` or `.parallel()` to build more complex control flows, exe
 
 In the example below, `clonedWorkflow` is a clone of `workflow1` and is used as a step within `testWorkflow`. The `clonedWorkflow` is run sequentially after `step1`.
 
-```typescript {6,20} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
+```typescript {5,9} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+import { createWorkflow, createStep, cloneWorkflow } from "@mastra/core/workflows";
 import { z } from "zod";
 
 const step1 = createStep({...});
-const workflow1 = createWorkflow({...});
-const clonedWorkflow = cloneWorkflow(workflow1, { id: "cloned-workflow" });
-const finalStep = createStep({...});
-
-export const testWorkflow = createWorkflow({
-  id: "test-workflow",
-  description: 'Test workflow',
-  inputSchema: z.object({
-    number: z.number()
-  }),
-  outputSchema: z.object({
-    number: z.number()
-  })
-})
+const clonedWorkflow = cloneWorkflow(step1, { id: "cloned-workflow" });
+
+export const testWorkflow = createWorkflow({...})
   .then(step1)
   .then(clonedWorkflow)
-  .then(finalStep)
   .commit();
 ```
-

package/.docs/raw/workflows/input-data-mapping.mdx

@@ -14,70 +14,30 @@ Input data mapping allows explicit mapping of values for the inputs of the next
 
 ## Map
 
-In this example the `output` from `cityCoordinatesStep` is transformed to match the `inputSchema` required for the `locationDetailsStep`. The values from the `cityCoordinatesStep` are available using the `inputData` parameter of the `.map` function.
+In this example the `output` from `step1` is transformed to match the `inputSchema` required for the `step2`. The value from `step1` is available using the `inputData` parameter of the `.map` function.
 
-```typescript {7-10,31,54,58} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-const cityCoordinatesStep = createStep({
-  id: "city-step",
-  description: "Gets details about a city",
-  inputSchema: z.object({
-    city: z.string()
-  }),
-  outputSchema: z.object({
-    city_name: z.string(),
-    country_name: z.string(),
-    country_timezone: z.string()
-  }),
-  execute: async ({ inputData }) => {
-    const { city } = inputData;
-    const geocodingResponse = await fetch(`https://geocoding-api.open-meteo.com/v1/search?name=${city}`);
-    const geocodingData = await geocodingResponse.json();
-
-    const { name, country, timezone } = geocodingData.results[0];
-
-    return {
-      city_name: name,
-      country_name: country,
-      country_timezone: timezone
-    };
-  }
-});
-
-const locationDetailsStep = createStep({
-  id: "location-step",
-  description: "Display location details",
-  inputSchema: z.object({
-    details: z.string()
-  }),
-  outputSchema: z.object({
-    outcome: z.string()
-  }),
-  execute: async ({ inputData }) => {
-    const { details } = inputData;
-    return {
-      outcome: details
-    };
-  }
-});
+```typescript {18} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+const step1 = createStep({...});
+const step2 = createStep({...});
 
 export const testWorkflow = createWorkflow({
   id: "test-workflow",
   description: 'Test workflow',
   inputSchema: z.object({
-    city: z.string()
+    input: z.number()
   }),
   outputSchema: z.object({
-    outcome: z.string()
+    output: z.string()
   })
 })
-  .then(cityCoordinatesStep)
+  .then(step1)
   .map(({ inputData }) => {
-    const { city_name, country_name, country_timezone } = inputData;
+    const { value } = inputData;
     return {
-      details: `${city_name}, ${country_name}, ${country_timezone}`
+      output: `${value}`
     };
   })
-  .then(locationDetailsStep)
+  .then(step2)
   .commit();
 ```
 
@@ -87,7 +47,7 @@ Use `inputData` to access the full output of the previous step:
 
 ```typescript {2} showLineNumbers
   .map(({ inputData }) => {
-    const { city_name, country_name, country_timezone } = inputData;
+    const { value} = inputData;
     ...
   })
 ```
@@ -97,62 +57,41 @@ Use `inputData` to access the full output of the previous step:
 Use `getStepResult` to access the full output of a specific step by referencing the step's instance:
 
 ```typescript {3} showLineNumbers
-  .then(cityCoordinatesStep)
+  .then(step1)
   .map(({ getStepResult }) => {
-    console.log(getStepResult(cityCoordinatesStep));
+    console.log(getStepResult(step1));
     ...
   })
 ```
 
-The above log would produce an output similar to the below:
-
-```typescript showLineNumbers
-{
-  city_name: 'London',
-  country_name: 'United Kingdom',
-  country_timezone: 'Europe/London'
-}
-```
-
 ### getInitData
 
 Use `getInitData` to access the initial input data provided to the workflow:
 
 ```typescript {3} showLineNumbers
-  .then(cityCoordinatesStep)
+  .then(step1)
   .map(({ getInitData }) => {
       console.log(getInitData());
     ...
   })
 ```
 
-The above log would produce an output similar to the below:
-
-```typescript showLineNumbers
-{ city: 'London' }
-```
 ## Renaming Outputs
 
 ### Step Outputs
 
-You can rename step outputs using the object syntax in `.map()`. In the example below, the `city_name` output from `cityCoordinatesStep` is renamed to `details`:
+You can rename step outputs using the object syntax in `.map()`. In the example below, the `value` output from `step1` is renamed to `details`:
 
 ```typescript {3} showLineNumbers
-  .then(cityCoordinatesStep)
+  .then(step)
   .map({
     details: {
-      step: cityCoordinatesStep,
-      path: "city_name"
+      step: step,
+      path: "value"
     }
   })
 ```
 
-The output would be similar to the below:
-
-```typescript showLineNumbers
-{ details: 'London' }
-```
-
 ### Workflow Outputs
 
 You can rename workflow outputs by using **referential composition**. This involves passing the workflow instance as the `initData`.
@@ -162,10 +101,10 @@ export const testWorkflow = createWorkflow({
   id: "test-workflow",
   description: 'Test workflow',
   inputSchema: z.object({
-    city: z.string()
+    input: z.string()
   }),
   outputSchema: z.object({
-    outcome: z.string()
+    output: z.string()
   })
 });
 
@@ -174,13 +113,7 @@ testWorkflow
   .map({
     details: {
       initData: testWorkflow,
-      path: "city"
+      path: "value"
     }
   })
 ```
-
-The output would be similar to the below:
-
-```typescript showLineNumbers
-{ details: 'London' }
-```

package/.docs/raw/workflows/overview.mdx

@@ -33,60 +33,38 @@ import { z } from "zod";
 
 Steps are the building blocks of workflows. Create a step using `createStep`:
 
-```typescript {1} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-const cityCoordinatesStep = createStep({
-  id: "city-step",
-  description: "Gets coordinates for city",
-  inputSchema: z.object({
-    city: z.string()
-  }),
-  outputSchema: z.object({
-    city_name: z.string(),
-    city_latitude: z.number(),
-    city_longitude: z.number()
-  }),
-  execute: async ({ inputData }) => {
-    const { city } = inputData;
-    const geocodingResponse = await fetch(`https://geocoding-api.open-meteo.com/v1/search?name=${city}`);
-    const geocodingData = await geocodingResponse.json();
-
-    const { name, latitude, longitude } = geocodingData.results[0];
-
-    return {
-      city_name: name,
-      city_latitude: latitude,
-      city_longitude: longitude
-    };
-  }
-});
+```typescript filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
+const step1 = createStep({...});
 ```
 
 > See [createStep](/reference/workflows/step) for more information.
 
 ### Create Workflow
 
-Create a workflow using `createWorkflow`. End a workflow using `.commit()`.
+Create a workflow using `createWorkflow` and complete it with `.commit()`.
 
 ```typescript {6,17} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
-const cityCoordinatesStep = createStep({...});
+const step1 = createStep({...});
 
 export const testWorkflow = createWorkflow({
   id: "test-workflow",
   description: 'Test workflow',
   inputSchema: z.object({
-    city: z.string()
+    input: z.string()
   }),
   outputSchema: z.object({
-    outcome: z.string()
+    output: z.string()
   })
 })
-  .then(cityCoordinatesStep)
+  .then(step1)
   .commit();
 ```
 
+> See [workflow](/reference/workflows/workflow) for more information.
+
 #### Composing Steps
 
 Workflow steps can be composed and executed sequentially using `.then()`.
@@ -95,21 +73,21 @@ Workflow steps can be composed and executed sequentially using `.then()`.
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
-const cityCoordinatesStep = createStep({...});
-const cityWeatherStep = createStep({...});
+const step1 = createStep({...});
+const step2 = createStep({...});
 
 export const testWorkflow = createWorkflow({
   id: "test-workflow",
   description: 'Test workflow',
   inputSchema: z.object({
-    city: z.string()
+    input: z.string()
   }),
   outputSchema: z.object({
-    outcome: z.string()
+    output: z.string()
   })
 })
-  .then(cityCoordinatesStep)
-  .then(cityWeatherStep)
+  .then(step1)
+  .then(step2)
   .commit();
 ```
 
@@ -121,26 +99,26 @@ export const testWorkflow = createWorkflow({
 Workflow steps can be cloned using `cloneStep()`, and used with any workflow method.
 
 ```typescript {5,19} filename="src/mastra/workflows/test-workflow.ts" showLineNumbers copy
-import { createWorkflow, createStep } from "@mastra/core/workflows";
+import { createWorkflow, createStep, cloneStep } from "@mastra/core/workflows";
 import { z } from "zod";
 
-const cityCoordinatesStep = createStep({...});
-const clonedStep = cloneStep(cityCoordinatesStep, { id: "cloned-step" });
-const cityWeatherStep = createStep({...});
+const step1 = createStep({...});
+const clonedStep = cloneStep(step1, { id: "cloned-step" });
+const step2 = createStep({...});
 
 export const testWorkflow = createWorkflow({
   id: "test-workflow",
   description: 'Test workflow',
   inputSchema: z.object({
-    city: z.string()
+    input: z.string()
   }),
   outputSchema: z.object({
-    outcome: z.string()
+    output: z.string()
   })
 })
-  .then(cityCoordinatesStep)
+  .then(step1)
   .then(clonedStep)
-  .then(cityWeatherStep)
+  .then(step2)
   .commit();
 ```
 
@@ -258,4 +236,3 @@ const result = await run.start({
 
 
 
-