@mastra/mcp-docs-server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

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

@@ -1,128 +0,0 @@
-# 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

@@ -1,60 +0,0 @@
-# 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

@@ -1,58 +0,0 @@
-# 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/deployment/cloud-providers/amazon-ec2.mdx

@@ -1,115 +0,0 @@
----
-title: "Amazon EC2"
-description: "Deploy your Mastra applications to Amazon EC2."
----
-
-import { Callout, Steps, Tabs } from "nextra/components";
-
-# Amazon EC2
-
-Deploy your Mastra applications to Amazon EC2 (Elastic Cloud Compute).
-
-<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](/docs/getting-started/installation)
-</Callout>
-
-## Prerequisites
-
-- An AWS account with [EC2](https://aws.amazon.com/ec2/) access
-- An EC2 instance running Ubuntu 24+ or Amazon Linux
-- A domain name with an A record pointing to your instance
-- A reverse proxy configured (e.g., using [nginx](https://nginx.org/))
-- SSL certificate configured (e.g., using [Let's Encrypt](https://letsencrypt.org/))
-- Node.js 18+ installed on your instance
-
-## Deployment Steps
-
-<Steps>
-
-### Clone your Mastra application
-
-Connect to your EC2 instance and clone your repository:
-
-<Tabs items={["Public Repository", "Private Repository"]}>
-<Tabs.Tab>
-
-```bash copy
-git clone https://github.com/<your-username>/<your-repository>.git
-```
-
-</Tabs.Tab>
-
-<Tabs.Tab>
-
-```bash copy
-git clone https://<your-username>:<your-personal-access-token>@github.com/<your-username>/<your-repository>.git
-```
-
-</Tabs.Tab>
-</Tabs>
-
-Navigate to the repository directory:
-
-```bash copy
-cd "<your-repository>"
-```
-
-### Install dependencies
-
-```bash copy
-npm install
-```
-
-### Set up environment variables
-
-Create a `.env` file and add your environment variables:
-
-```bash copy
-touch .env
-```
-
-Edit the `.env` file and add your environment variables:
-
-```bash copy
-OPENAI_API_KEY=<your-openai-api-key>
-# Add other required environment variables
-```
-
-### Build the application
-
-```bash copy
-npm run build
-```
-
-### Run the application
-
-```bash copy
-node --import=./.mastra/output/instrumentation.mjs --env-file=".env" .mastra/output/index.mjs
-```
-
-<Callout>
-Your Mastra application will run on port 4111 by default. Ensure your reverse proxy is configured to forward requests to this port.
-</Callout>
-
-</Steps>
-
-## 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](/docs/client-js/overview) for more information.
-
-```typescript copy showLineNumbers
-import { MastraClient } from "@mastra/client-js";
-
-const mastraClient = new MastraClient({
-  baseUrl: "https://<your-domain-name>",
-});
-```
-
-## Next steps
-
-- [Mastra Client SDK](/docs/client-js/overview)

package/.docs/raw/deployment/cloud-providers/aws-lambda.mdx

@@ -1,273 +0,0 @@
----
-title: "AWS Lambda"
-description: "Deploy your Mastra applications to AWS Lambda using Docker containers and the AWS Lambda Web Adapter."
----
-
-import { Callout, Steps } from "nextra/components";
-
-# AWS Lambda
-
-Deploy your Mastra applications to AWS Lambda using Docker containers and the AWS Lambda Web Adapter.
-This approach allows you to run your Mastra server as a containerized Lambda function with automatic scaling.
-
-<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](/docs/getting-started/installation)
-</Callout>
-
-## Prerequisites
-
-Before deploying to AWS Lambda, ensure you have:
-
-- [AWS CLI](https://aws.amazon.com/cli/) installed and configured
-- [Docker](https://www.docker.com/) installed and running
-- An AWS account with appropriate permissions for Lambda, ECR, and IAM
-- Your Mastra application configured with appropriate memory storage
-
-## Memory Configuration
-
-<Callout>
-  AWS Lambda 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>
-
-Lambda functions have limitations with file system storage. Configure your Mastra application to use either in-memory or external storage providers:
-
-### Option 1: In-Memory (Simplest)
-
-```typescript filename="src/mastra/index.ts" copy showLineNumbers
-import { LibSQLStore } from "@mastra/libsql";
-
-const storage = new LibSQLStore({
-  url: ":memory:", // in-memory storage
-});
-```
-
-### Option 2: External Storage Providers
-
-For persistent memory across Lambda invocations, use external storage providers like `LibSQLStore` with Turso or other storage providers like `PostgreStore`:
-
-```typescript filename="src/mastra/index.ts" copy showLineNumbers
-import { LibSQLStore } from "@mastra/libsql";
-
-const storage = new LibSQLStore({
-  url: "libsql://your-database.turso.io", // External Turso database
-  authToken: process.env.TURSO_AUTH_TOKEN,
-});
-```
-
-For more memory configuration options, see the [Memory documentation](/docs/memory/overview).
-
-## Creating a Dockerfile
-
-Create a `Dockerfile` in your Mastra project root directory:
-
-```dockerfile filename="Dockerfile" copy showLineNumbers
-FROM node:22-alpine
-
-WORKDIR /app
-COPY package*.json ./
-RUN npm ci
-COPY src ./src
-RUN npx mastra build
-RUN apk add --no-cache gcompat
-
-COPY --from=public.ecr.aws/awsguru/aws-lambda-adapter:0.9.0 /lambda-adapter /opt/extensions/lambda-adapter
-RUN addgroup -g 1001 -S nodejs && \
-  adduser -S mastra -u 1001 && \
-  chown -R mastra:nodejs /app
-
-USER mastra
-
-ENV PORT=8080
-ENV NODE_ENV=production
-ENV READINESS_CHECK_PATH="/api"
-
-EXPOSE 8080
-
-CMD ["node", "--import=./.mastra/output/instrumentation.mjs", ".mastra/output/index.mjs"]
-```
-
-## Building and Deploying
-
-<Steps>
-
-### Set up environment variables
-
-Set up your environment variables for the deployment process:
-
-```bash copy
-export PROJECT_NAME="your-mastra-app"
-export AWS_REGION="us-east-1"
-export AWS_ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)
-```
-
-### Build the Docker image
-
-Build your Docker image locally:
-
-```bash copy
-docker build -t "$PROJECT_NAME" .
-```
-
-### Create an ECR repository
-
-Create an Amazon ECR repository to store your Docker image:
-
-```bash copy
-aws ecr create-repository --repository-name "$PROJECT_NAME" --region "$AWS_REGION"
-```
-
-### Authenticate Docker with ECR
-
-Log in to Amazon ECR:
-
-```bash copy
-aws ecr get-login-password --region "$AWS_REGION" | docker login --username AWS --password-stdin "$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com"
-```
-
-### Tag and push the image
-
-Tag your image with the ECR repository URI and push it:
-
-```bash copy
-docker tag "$PROJECT_NAME":latest "$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$PROJECT_NAME":latest
-docker push "$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com/$PROJECT_NAME":latest
-```
-
-### Create the Lambda function
-
-Create a Lambda function using the AWS Console:
-
-1. Navigate to the [AWS Lambda Console](https://console.aws.amazon.com/lambda/)
-2. Click **Create function**
-3. Select **Container image**
-4. Configure the function:
-   - **Function name**: Your function name (e.g., `mastra-app`)
-   - **Container image URI**: Click **Browse images** and select your ECR repository, then choose the `latest` tag
-   - **Architecture**: Select the architecture that matches your Docker build (typically `x86_64`)
-
-### Configure Function URL
-
-Enable Function URL for external access:
-
-1. In the Lambda function configuration, go to **Configuration** > **Function URL**
-2. Click **Create function URL**
-3. Set **Auth type** to **NONE** (for public access)
-4. Configure **CORS** settings:
-   - **Allow-Origin**: `*` (restrict to your domain in production)
-   - **Allow-Headers**: `content-type`
-   - **Allow-Methods**: `*` (audit and restrict in production)
-5. Click **Save**
-
-### Configure environment variables
-
-Add your environment variables in the Lambda function configuration:
-
-1. Go to **Configuration** > **Environment variables**
-2. Add the required variables for your Mastra application:
-   - `OPENAI_API_KEY`: Your OpenAI API key (if using OpenAI)
-   - `ANTHROPIC_API_KEY`: Your Anthropic API key (if using Anthropic)
-   - `TURSO_AUTH_TOKEN`: Your Turso auth token (if using LibSQL with Turso)
-   - Other provider-specific API keys as needed
-
-### Adjust function settings
-
-Configure the function's memory and timeout settings:
-
-1. Go to **Configuration** > **General configuration**
-2. Set the following recommended values:
-   - **Memory**: 512 MB (adjust based on your application needs)
-   - **Timeout**: 30 seconds (adjust based on your application needs)
-   - **Ephemeral storage**: 512 MB (optional, for temporary files)
-
-</Steps>
-
-## Testing your deployment
-
-Once deployed, test your Lambda function:
-
-1. Copy the **Function URL** from the Lambda console
-2. Visit the URL in your browser to see your Mastra's server home screen
-3. Test your agents and workflows using the generated API endpoints
-
-For more information about available API endpoints, see the [Server documentation](/docs/deployment/server).
-
-## Connecting your client
-
-Update your client application to use the Lambda function URL:
-
-```typescript filename="src/client.ts" copy showLineNumbers
-import { MastraClient } from "@mastra/client-js";
-
-const mastraClient = new MastraClient({
-  baseUrl: "https://your-function-url.lambda-url.us-east-1.on.aws",
-});
-```
-
-## Troubleshooting
-
-### Function timeout errors
-
-If your Lambda function times out:
-
-- Increase the timeout value in **Configuration** > **General configuration**
-- Optimize your Mastra application for faster cold starts
-- Consider using provisioned concurrency for consistent performance
-
-### Memory issues
-
-If you encounter memory-related errors:
-
-- Increase the memory allocation in **Configuration** > **General configuration**
-- Monitor memory usage in CloudWatch Logs
-- Optimize your application's memory usage
-
-### CORS issues
-
-If you encounter CORS errors when accessing endpoints but not the home page:
-
-- Verify CORS headers are properly set in your Mastra server configuration
-- Check the Lambda Function URL CORS configuration
-- Ensure your client is making requests to the correct URL
-
-### Container image issues
-
-If the Lambda function fails to start:
-
-- Verify the Docker image builds successfully locally
-- Check that the `CMD` instruction in your Dockerfile is correct
-- Review CloudWatch Logs for container startup errors
-- Ensure the Lambda Web Adapter is properly installed in the container
-
-## Production considerations
-
-For production deployments:
-
-### Security
-
-- Restrict CORS origins to your trusted domains
-- Use AWS IAM roles for secure access to other AWS services
-- Store sensitive environment variables in AWS Secrets Manager or Parameter Store
-
-### Monitoring
-
-- Enable CloudWatch monitoring for your Lambda function
-- Set up CloudWatch alarms for errors and performance metrics
-- Use AWS X-Ray for distributed tracing
-
-### Scaling
-
-- Configure provisioned concurrency for predictable performance
-- Monitor concurrent executions and adjust limits as needed
-- Consider using Application Load Balancer for more complex routing needs
-
-## Next steps
-
-- [Mastra Client SDK](/docs/client-js/overview)
-- [AWS Lambda documentation](https://docs.aws.amazon.com/lambda/)
-- [AWS Lambda Web Adapter](https://github.com/awslabs/aws-lambda-web-adapter)