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

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",
   "description": "MCP server for accessing Mastra.ai documentation, changelogs, and news.",
   "type": "module",
   "main": "dist/index.js",
@@ -32,7 +32,7 @@
     "uuid": "^11.1.0",
     "zod": "^3.25.67",
     "zod-to-json-schema": "^3.24.5",
-    "@mastra/mcp": "^0.10.5-alpha.2"
+    "@mastra/mcp": "^0.10.5"
   },
   "devDependencies": {
     "@hono/node-server": "^1.14.4",
@@ -47,8 +47,8 @@
     "tsx": "^4.19.4",
     "typescript": "^5.8.3",
     "vitest": "^3.2.3",
-    "@internal/lint": "0.0.13",
-    "@mastra/core": "0.10.7-alpha.4"
+    "@internal/lint": "0.0.14",
+    "@mastra/core": "0.10.7"
   },
   "peerDependencies": {
     "@mastra/core": "^0.10.0-alpha.0"