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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/mcp-docs-server",
-  "version": "0.13.2-alpha.2",
+  "version": "0.13.2-alpha.3",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",