@mastra/mcp-docs-server 0.13.2-alpha.1 → 0.13.2-alpha.3

package/.docs/raw/course/04-workflows/16-building-parallel-workflow.md

@@ -0,0 +1,100 @@
+# Building Parallel Workflow
+
+Now you'll create a workflow that runs your analysis steps in parallel for maximum performance.
+
+## Creating the Parallel Workflow
+
+Add this workflow to your file:
+
+```typescript
+export const parallelAnalysisWorkflow = createWorkflow({
+  id: "parallel-analysis-workflow",
+  description: "Run multiple content analyses in parallel",
+  inputSchema: z.object({
+    content: z.string(),
+    type: z.enum(["article", "blog", "social"]).default("article"),
+  }),
+  outputSchema: z.object({
+    results: z.object({
+      seo: z.object({
+        seoScore: z.number(),
+        keywords: z.array(z.string()),
+      }),
+      readability: z.object({
+        readabilityScore: z.number(),
+        gradeLevel: z.string(),
+      }),
+      sentiment: z.object({
+        sentiment: z.enum(["positive", "neutral", "negative"]),
+        confidence: z.number(),
+      }),
+    }),
+  }),
+})
+  .parallel([seoAnalysisStep, readabilityStep, sentimentStep])
+  .then(
+    createStep({
+      id: "combine-results",
+      description: "Combines parallel analysis results",
+      inputSchema: z.object({
+        "seo-analysis": z.object({
+          seoScore: z.number(),
+          keywords: z.array(z.string()),
+        }),
+        "readability-analysis": z.object({
+          readabilityScore: z.number(),
+          gradeLevel: z.string(),
+        }),
+        "sentiment-analysis": z.object({
+          sentiment: z.enum(["positive", "neutral", "negative"]),
+          confidence: z.number(),
+        }),
+      }),
+      outputSchema: z.object({
+        results: z.object({
+          seo: z.object({
+            seoScore: z.number(),
+            keywords: z.array(z.string()),
+          }),
+          readability: z.object({
+            readabilityScore: z.number(),
+            gradeLevel: z.string(),
+          }),
+          sentiment: z.object({
+            sentiment: z.enum(["positive", "neutral", "negative"]),
+            confidence: z.number(),
+          }),
+        }),
+      }),
+      execute: async ({ inputData }) => {
+        console.log("🔄 Combining parallel results...");
+
+        return {
+          results: {
+            seo: inputData["seo-analysis"],
+            readability: inputData["readability-analysis"],
+            sentiment: inputData["sentiment-analysis"],
+          },
+        };
+      },
+    }),
+  )
+  .commit();
+```
+
+## Understanding Parallel Data Flow
+
+When steps run in parallel:
+
+1. Each step receives the same input data
+2. Steps execute simultaneously
+3. Results are collected into an object with step IDs as keys
+4. The next step receives all parallel results
+
+## Key Points
+
+- **`.parallel([step1, step2, step3])`**: Runs all steps simultaneously
+- **Result object keys**: Use the step IDs (e.g., "seo-analysis")
+- **Combine step**: Processes all parallel results together
+
+Next, you'll test this parallel workflow and see the performance improvement!

package/.docs/raw/course/04-workflows/17-testing-parallel-performance.md

@@ -0,0 +1,40 @@
+# Testing Parallel Workflow
+
+Let's test your parallel workflow.
+
+## Registering the New Workflow
+
+Update your Mastra configuration to include your new workflow workflows:
+
+```typescript
+// In src/mastra/index.ts
+import {
+  contentWorkflow,
+  aiContentWorkflow,
+  parallelAnalysisWorkflow,
+} from "./workflows/content-workflow";
+
+export const mastra = new Mastra({
+  workflows: {
+    contentWorkflow,
+    aiContentWorkflow,
+    parallelAnalysisWorkflow, // Add the parallel workflow
+  },
+  // ... rest of configuration
+});
+```
+
+## Testing the Parallel Workflow
+
+You can now test this new workflow in the Playground. You will notice that it processes the three analysis steps in parallel speeding up execution time.
+
+## When to Use Parallel Execution
+
+Use parallel execution when:
+
+- Steps don't depend on each other's outputs
+- Steps involve I/O operations (API calls, database queries)
+- You want to maximize performance
+- Steps process the same input data
+
+Register your parallel workflow with Mastra to use it in the playground! Next, you'll learn about conditional branching.

package/.docs/raw/course/04-workflows/18-understanding-conditional-branching.md

@@ -0,0 +1,58 @@
+# Understanding Conditional Branching
+
+Learn how to create workflows that take different paths based on data conditions, making your workflows more intelligent and adaptive.
+
+## What is Conditional Branching?
+
+Conditional branching allows workflows to:
+- **Make decisions**: Choose different processing paths based on data
+- **Handle variations**: Process different content types differently  
+- **Optimize performance**: Skip unnecessary steps for certain inputs
+- **Customize behavior**: Provide different experiences based on conditions
+
+## Real-World Example
+
+Imagine a content processing workflow that:
+- **Short content** (< 50 words): Gets quick processing
+- **Medium content** (50-200 words): Gets standard processing
+- **Long content** (> 200 words): Gets detailed processing with extra analysis
+
+## Basic Branching Syntax
+
+```typescript
+.branch([
+  [condition1, step1],
+  [condition2, step2],
+  [condition3, step3]
+])
+```
+
+Where:
+- **condition**: An async function that returns `true` or `false`
+- **step**: The step to execute if the condition is `true`
+
+## Condition Functions
+
+Conditions are functions that examine the input data:
+
+```typescript
+// Example condition function
+async ({ inputData }) => {
+  return inputData.wordCount < 50;
+}
+```
+
+## Multiple Paths
+
+- If multiple conditions are `true`, **all matching steps run in parallel**
+- If no conditions are `true`, the workflow continues without executing any branch steps
+- Conditions are evaluated in order, but matching steps run simultaneously
+
+## Benefits
+
+- **Smart routing**: Send data down the most appropriate path
+- **Performance**: Skip expensive operations when not needed
+- **Flexibility**: Handle different scenarios in one workflow
+- **Maintainability**: Clear logic for different processing paths
+
+Next, you'll create a workflow with conditional branches!

package/.docs/raw/course/04-workflows/19-creating-conditional-steps.md

@@ -0,0 +1,128 @@
+# Creating Conditional Steps
+
+Let's create two processing steps for different types of content: one for short and simple content, and one for everything else.
+
+## Assessment Step
+
+First, create a step that analyzes content to determine which path to take:
+
+```typescript
+const assessContentStep = createStep({
+  id: "assess-content",
+  description: "Assesses content to determine processing path",
+  inputSchema: z.object({
+    content: z.string(),
+    type: z.enum(["article", "blog", "social"]).default("article"),
+  }),
+  outputSchema: z.object({
+    content: z.string(),
+    type: z.enum(["article", "blog", "social"]).default("article"),
+    wordCount: z.number(),
+    complexity: z.enum(["simple", "moderate", "complex"]),
+    category: z.enum(["short", "medium", "long"]),
+  }),
+  execute: async ({ inputData }) => {
+    const { content, type } = inputData;
+    const words = content.trim().split(/\s+/);
+    const wordCount = words.length;
+
+    // Determine category by length
+    let category: "short" | "medium" | "long" = "short";
+    if (wordCount >= 50) category = "medium";
+    if (wordCount >= 200) category = "long";
+
+    // Determine complexity by average word length
+    const avgWordLength =
+      words.reduce((sum, word) => sum + word.length, 0) / wordCount;
+    let complexity: "simple" | "moderate" | "complex" = "simple";
+    if (avgWordLength > 5) complexity = "moderate";
+    if (avgWordLength > 7) complexity = "complex";
+
+    console.log(`📋 Assessment: ${category} content, ${complexity} complexity`);
+
+    return {
+      content,
+      type,
+      wordCount,
+      complexity,
+      category,
+    };
+  },
+});
+```
+
+## Quick Processing Step
+
+For short, simple content:
+
+```typescript
+const quickProcessingStep = createStep({
+  id: "quick-processing",
+  description: "Quick processing for short and simple content",
+  inputSchema: z.object({
+    content: z.string(),
+    type: z.enum(["article", "blog", "social"]).default("article"),
+    wordCount: z.number(),
+    complexity: z.enum(["simple", "moderate", "complex"]),
+    category: z.enum(["short", "medium", "long"]),
+  }),
+  outputSchema: z.object({
+    processedContent: z.string(),
+    processingType: z.string(),
+    recommendations: z.array(z.string()),
+  }),
+  execute: async ({ inputData }) => {
+    console.log("⚡ Quick processing for short and simple content...");
+
+    return {
+      processedContent: inputData.content,
+      processingType: "quick",
+      recommendations: [
+        "Content is concise",
+        "Consider expanding for more detail",
+      ],
+    };
+  },
+});
+```
+
+## General Processing Step
+
+For all other content (not short and simple):
+
+```typescript
+const generalProcessingStep = createStep({
+  id: "general-processing",
+  description: "General processing for all other content",
+  inputSchema: z.object({
+    content: z.string(),
+    type: z.enum(["article", "blog", "social"]).default("article"),
+    wordCount: z.number(),
+    complexity: z.enum(["simple", "moderate", "complex"]),
+    category: z.enum(["short", "medium", "long"]),
+  }),
+  outputSchema: z.object({
+    processedContent: z.string(),
+    processingType: z.string(),
+    recommendations: z.array(z.string()),
+  }),
+  execute: async ({ inputData }) => {
+    console.log("📝 General processing for non-short/simple content...");
+
+    // Simulate more involved processing
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    return {
+      processedContent: inputData.content,
+      processingType: "general",
+      recommendations: [
+        "Consider simplifying content",
+        "Break up long paragraphs",
+        "Add examples or explanations if needed",
+      ],
+    };
+  },
+});
+```
+
+These two steps will be used in different branches based on the content assessment. Next, you'll create the conditional workflow!

package/.docs/raw/course/04-workflows/20-building-conditional-workflow.md

@@ -0,0 +1,60 @@
+# Building Conditional Workflow
+
+Now you'll create a workflow that uses conditional branching to route content through two different processing paths.
+
+## Creating the Conditional Workflow
+
+Add this workflow to your file:
+
+```typescript
+export const conditionalWorkflow = createWorkflow({
+  id: "conditional-workflow",
+  description: "Content processing with conditional branching",
+  inputSchema: z.object({
+    content: z.string(),
+    type: z.enum(["article", "blog", "social"]).default("article"),
+  }),
+  outputSchema: z.object({
+    processedContent: z.string(),
+    processingType: z.string(),
+    recommendations: z.array(z.string()),
+  }),
+})
+  .then(assessContentStep)
+  .branch([
+    // Branch 1: Short and simple content
+    [
+      async ({ inputData }) =>
+        inputData.category === "short" && inputData.complexity === "simple",
+      quickProcessingStep,
+    ],
+    // Branch 2: Everything else
+    [
+      async ({ inputData }) =>
+        !(inputData.category === "short" && inputData.complexity === "simple"),
+      generalProcessingStep,
+    ],
+  ])
+  .commit();
+```
+
+## Understanding the Conditions
+
+1. **Short + Simple**: Quick processing with minimal recommendations
+2. **Everything Else**: General processing with more suggestions
+
+## Multiple Conditions
+
+You can combine conditions using logical operators:
+
+- **`&&`**: AND - both conditions must be true
+- **`||`**: OR - either condition can be true
+- **`!`**: NOT - condition must be false
+
+## Condition Evaluation
+
+- Conditions are checked in order
+- Multiple conditions can be true (steps run in parallel)
+- If no conditions match, the branch is skipped
+
+Next, you'll test this conditional workflow with different types of content!

package/.docs/raw/course/04-workflows/21-testing-conditional-logic.md

@@ -0,0 +1,58 @@
+# Testing Conditional Logic
+
+Let's test your conditional workflow with different types of content to see how it routes to different processing paths.
+
+## Registering the New Workflow
+
+Update your Mastra configuration to include your new workflow workflows:
+
+```typescript
+// In src/mastra/index.ts
+import {
+  contentWorkflow,
+  aiContentWorkflow,
+  parallelAnalysisWorkflow,
+  conditionalWorkflow,
+} from "./workflows/content-workflow";
+
+export const mastra = new Mastra({
+  workflows: {
+    contentWorkflow,
+    aiContentWorkflow,
+    parallelAnalysisWorkflow,
+    conditionalWorkflow, // Add the conditional workflow
+  },
+  // ... rest of configuration
+});
+```
+
+## Testing the conditional workflow
+
+You can now test this new conditional workflow in the playground. Be sure to test different content lengths and content types.
+
+## Understanding the Flow
+
+1. **Assessment step** analyzes content and determines category/complexity
+2. **Branch conditions** are evaluated against the assessment results
+3. **Matching step** executes based on which condition(s) are true
+4. **Results** show which processing path was taken
+
+## Debugging Conditions
+
+If a condition isn't working as expected:
+
+- Check the assessment step output
+- Verify condition logic matches your expectations
+- Test individual conditions in isolation
+- Add console.log statements to track condition evaluation
+
+## Branch Benefits
+
+Conditional workflows provide:
+
+- **Intelligent routing**: Right processing for right content
+- **Performance optimization**: Skip heavy processing for simple content
+- **Customized experience**: Different handling for different scenarios
+- **Scalable logic**: Easy to add new conditions and processing paths
+
+Next, you'll learn about streaming workflow results for better user experience!

package/.docs/raw/course/04-workflows/22-conclusion.md

@@ -0,0 +1,58 @@
+# Conclusion
+
+Congratulations! You've completed the Mastra Workflows course and learned how to build powerful, type-safe workflows that can handle complex automation tasks.
+
+## What You've Accomplished
+
+Throughout this course, you've learned to:
+
+### Core Concepts
+
+- **Understanding workflows**: How they break complex tasks into manageable steps
+- **Creating steps**: Building reusable units with clear inputs and outputs
+- **Schema validation**: Using Zod for type safety and runtime validation
+- **Error handling**: Making workflows robust and user-friendly
+
+### Building Workflows
+
+- **Chaining steps**: Connecting steps to create complete workflows
+- **Testing thoroughly**: Ensuring reliability with comprehensive tests
+- **Registering with Mastra**: Integrating workflows into your application
+- **Using the playground**: Visual testing and debugging
+
+### Advanced Features
+
+- **AI integration**: Combining workflows with agents for intelligent processing
+- **Parallel execution**: Running multiple steps simultaneously for better performance
+- **Conditional branching**: Creating smart workflows that adapt to different scenarios
+
+## Key Workflows You Built
+
+1. **Content Processing Workflow**: Validates, enhances, and summarizes content
+2. **AI-Enhanced Workflow**: Adds intelligent analysis with AI agents
+3. **Parallel Analysis Workflow**: Demonstrates high-performance parallel execution
+4. **Conditional Workflow**: Shows intelligent routing based on content characteristics
+
+## Next Steps
+
+Now that you understand workflows, you can:
+
+### Expand Your Skills
+
+- **Explore more integrations**: Connect workflows with databases, APIs, and external services
+- **Build complex automations**: Create multi-step business processes
+- **Integrate with web applications**: Use workflows in your frontend applications
+- **Scale for production**: Deploy workflows with proper monitoring and error handling
+
+## Final Thoughts
+
+Workflows are a powerful way to build reliable, maintainable automation systems. The patterns and principles you've learned in this course will help you tackle increasingly complex challenges as you build AI-powered applications.
+
+Remember:
+
+- **Start simple**: Begin with basic workflows and add complexity gradually
+- **Test thoroughly**: Good testing prevents production issues
+- **Think in steps**: Break complex problems into smaller, manageable pieces
+- **Embrace type safety**: Let schemas catch errors early
+
+Thank you for completing the Mastra Workflows lesson. Happy building! 🚀

package/.docs/raw/deployment/cloud-providers/digital-ocean.mdx

@@ -0,0 +1,111 @@
+---
+title: "Digital Ocean"
+description: "Deploy your Mastra applications to Digital Ocean."
+---
+
+import { Callout, Steps, Tabs } from "nextra/components";
+import ServerConfig from "@/components/content-blocks/server-config.mdx";
+
+## Digital Ocean
+
+Deploy your Mastra applications to Digital Ocean's App Platform and Droplets.
+
+<Callout>
+  This guide assumes your Mastra application has been created using the default
+  `npx create-mastra@latest` command.
+  For more information on how to create a new Mastra application,
+  refer to our [getting started guide](./../../getting-started/installation.mdx)
+</Callout>
+
+<Tabs items={["App Platform", "Droplets"]}>
+
+<Tabs.Tab>
+
+### App Platform
+
+#### Prerequisites [#app-platform-prerequisites]
+
+- A Git repository containing your Mastra application. This can be a GitHub repository, GitLab repository, or any other compatible source provider.
+- A Digital Ocean account
+
+#### Deployment Steps
+
+<Steps>
+
+#### Create a new App
+
+- Log in to your Digital Ocean dashboard.
+- Navigate to the App Platform service.
+- Select your source provider and create a new app.
+
+#### Configure Deployment Source
+
+- Connect and select your repository. You may also choose a container image or a sample app.
+- Select the branch you want to deploy from.
+- Configure the source directory if necessary. If your Mastra application uses the default directory structure, no action is required here.
+- Head to the next step.
+
+#### Configure Resource Settings and Environment Variables
+
+- A Node.js build should be detected automatically.
+- Add any required environment variables for your Mastra application. This includes API keys, database URLs, and other configuration values.
+- You may choose to configure the size of your resource here.
+- Other things you may optionally configure include, the region of your resource, the unique app name, and what project the resource belongs to.
+- Once you're done, you may create the app after reviewing your configuration and pricing estimates.
+
+#### Deployment
+
+- Your app will be built and deployed automatically.
+- Digital Ocean will provide you with a URL to access your deployed application.
+
+</Steps>
+
+You can now access your deployed application at the URL provided by Digital Ocean.
+
+<Callout>
+The Digital Ocean App Platform uses an ephemeral file system,
+meaning that any files written to the file system are short-lived and may be lost.
+Avoid using a Mastra storage provider that uses the file system,
+such as `LibSQLStore` with a file URL.
+</Callout>
+
+</Tabs.Tab>
+
+<Tabs.Tab>
+
+### Droplets
+
+Deploy your Mastra application to Digital Ocean's Droplets.
+This guide will cover setting up a droplet, a reverse proxy using Nginx, and running your Mastra application.
+
+<Callout>
+The guide assumes your droplet runs Ubuntu 24+.
+</Callout>
+
+#### Prerequisites [#droplets-prerequisites]
+
+- A Digital Ocean account
+- A droplet running Ubuntu 24+
+- A domain name with an A record pointing to your droplet
+
+#### Setting up the droplet
+
+<ServerConfig />
+
+</Tabs.Tab>
+
+</Tabs>
+
+### Connect to your Mastra server
+
+You can now connect to your Mastra server from your client application using a `MastraClient` from the `@mastra/client-js` package.
+
+Refer to the [`MastraClient` documentation](../../client-js/overview.mdx) for more information.
+
+```typescript copy showLineNumbers
+import { MastraClient } from "@mastra/client-js";
+
+const mastraClient = new MastraClient({
+  baseUrl: "https://<your-domain-name>",
+});
+```

package/.docs/raw/deployment/cloud-providers/index.mdx

@@ -0,0 +1,15 @@
+---
+title: "Cloud Providers"
+description: "Deploy your Mastra applications to popular cloud providers."
+asIndexPage: true
+---
+
+import { CardGrid, CardGridItem } from "@/components/cards/card-grid";
+
+## Cloud Providers
+
+Deploy your Mastra applicaitons to popular cloud providers.
+
+<CardGrid>
+  <CardGridItem title="Digital Ocean" description="Deploy your Mastra applications to Digital Ocean" href="./cloud-providers/digital-ocean" />
+</CardGrid>