@mastra/mcp-docs-server 1.0.0-beta.13 → 1.0.0-beta.14

package/.docs/raw/guides/deployment/inngest.mdx

@@ -0,0 +1,386 @@
+---
+title: "Inngest | Deployment"
+description: "Deploy Mastra workflows with Inngest"
+---
+
+# Inngest Workflow
+
+[Inngest](https://www.inngest.com/docs) is a developer platform for building and running background workflows, without managing infrastructure.
+
+For a complete example with advanced flow control features, see the [Inngest workflow example](https://github.com/mastra-ai/mastra/tree/main/examples/inngest).
+
+## How Inngest Works with Mastra
+
+Inngest and Mastra integrate by aligning their workflow models: Inngest organizes logic into functions composed of steps, and Mastra workflows defined using `createWorkflow` and `createStep` map directly onto this paradigm. Each Mastra workflow becomes an Inngest function with a unique identifier, and each step within the workflow maps to an Inngest step.
+
+The `serve` function bridges the two systems by registering Mastra workflows as Inngest functions and setting up the necessary event handlers for execution and monitoring.
+
+When an event triggers a workflow, Inngest executes it step by step, memoizing each step's result. This means if a workflow is retried or resumed, completed steps are skipped, ensuring efficient and reliable execution. Control flow primitives in Mastra, such as loops, conditionals, and nested workflows are seamlessly translated into the same Inngest's function/step model, preserving advanced workflow features like composition, branching, and suspension.
+
+Real-time monitoring, suspend/resume, and step-level observability are enabled via Inngest's publish-subscribe system and dashboard. As each step executes, its state and output are tracked using Mastra storage and can be resumed as needed.
+
+## Setup
+
+Install the required Inngest package:
+
+```sh
+npm install @mastra/inngest@beta
+```
+
+## Building an Inngest Workflow
+
+This guide walks through creating a workflow with Inngest and Mastra, demonstrating a counter application that increments a value until it reaches 10.
+
+### Inngest Initialization
+
+Initialize the Inngest integration to obtain Mastra-compatible workflow helpers. The createWorkflow and createStep functions are used to create workflow and step objects that are compatible with Mastra and inngest.
+
+In development:
+
+```ts title="src/mastra/inngest/index.ts"
+import { Inngest } from "inngest";
+import { realtimeMiddleware } from "@inngest/realtime/middleware";
+
+export const inngest = new Inngest({
+  id: "mastra",
+  baseUrl: "http://localhost:8288",
+  isDev: true,
+  middleware: [realtimeMiddleware()],
+});
+```
+
+In production:
+
+```ts title="src/mastra/inngest/index.ts"
+import { Inngest } from "inngest";
+import { realtimeMiddleware } from "@inngest/realtime/middleware";
+
+export const inngest = new Inngest({
+  id: "mastra",
+  middleware: [realtimeMiddleware()],
+});
+```
+
+### Creating Steps
+
+Define the individual steps that will compose your workflow:
+
+```ts title="src/mastra/workflows/index.ts"
+import { z } from "zod";
+import { inngest } from "../inngest";
+import { init } from "@mastra/inngest";
+
+// Initialize Inngest with Mastra, pointing to your local Inngest server
+const { createWorkflow, createStep } = init(inngest);
+
+// Step: Increment the counter value
+const incrementStep = createStep({
+  id: "increment",
+  inputSchema: z.object({
+    value: z.number(),
+  }),
+  outputSchema: z.object({
+    value: z.number(),
+  }),
+  execute: async ({ inputData }) => {
+    return { value: inputData.value + 1 };
+  },
+});
+```
+
+### Creating the Workflow
+
+Compose the steps into a workflow using the `dountil` loop pattern. The createWorkflow function creates a function on inngest server that is invocable.
+
+```ts title="src/mastra/workflows/index.ts"
+// workflow that is registered as a function on inngest server
+const workflow = createWorkflow({
+  id: "increment-workflow",
+  inputSchema: z.object({
+    value: z.number(),
+  }),
+  outputSchema: z.object({
+    value: z.number(),
+  }),
+}).then(incrementStep);
+
+workflow.commit();
+
+export { workflow as incrementWorkflow };
+```
+
+### Configuring the Mastra Instance and Executing the Workflow
+
+Register the workflow with Mastra and configure the Inngest API endpoint:
+
+```ts title="src/mastra/index.ts"
+import { Mastra } from "@mastra/core";
+import { serve as inngestServe } from "@mastra/inngest";
+import { incrementWorkflow } from "./workflows";
+import { inngest } from "./inngest";
+import { PinoLogger } from "@mastra/loggers";
+
+// Configure Mastra with the workflow and Inngest API endpoint
+export const mastra = new Mastra({
+  workflows: {
+    incrementWorkflow,
+  },
+  server: {
+    // The server configuration is required to allow local docker container can connect to the mastra server
+    host: "0.0.0.0",
+    apiRoutes: [
+      // This API route is used to register the Mastra workflow (inngest function) on the inngest server
+      {
+        path: "/api/inngest",
+        method: "ALL",
+        createHandler: async ({ mastra }) => inngestServe({ mastra, inngest }),
+        // The inngestServe function integrates Mastra workflows with Inngest by:
+        // 1. Creating Inngest functions for each workflow with unique IDs (workflow.${workflowId})
+        // 2. Setting up event handlers that:
+        //    - Generate unique run IDs for each workflow execution
+        //    - Create an InngestExecutionEngine to manage step execution
+        //    - Handle workflow state persistence and real-time updates
+        // 3. Establishing a publish-subscribe system for real-time monitoring
+        //    through the workflow:${workflowId}:${runId} channel
+        //
+        // Optional: You can also pass additional Inngest functions to serve alongside workflows:
+        // createHandler: async ({ mastra }) => inngestServe({
+        //   mastra,
+        //   inngest,
+        //   functions: [customFunction1, customFunction2] // User-defined Inngest functions
+        // }),
+      },
+    ],
+  },
+  logger: new PinoLogger({
+    name: "Mastra",
+    level: "info",
+  }),
+});
+```
+
+### Running the Workflow locally
+
+:::info[Prerequisites]
+
+- Docker installed and running
+- Mastra project set up
+- Dependencies installed (`npm install`)
+
+:::
+
+1. Run `npx mastra dev` to start the Mastra server on local to serve the server on port 4111.
+2. Start the Inngest Dev Server (via Docker)
+   In a new terminal, run:
+
+    ```sh
+    docker run --rm -p 8288:8288 \
+      inngest/inngest \
+      inngest dev -u http://host.docker.internal:4111/api/inngest
+    ```
+
+    :::note
+
+    The URL after `-u` tells the Inngest dev server where to find your Mastra `/api/inngest` endpoint.
+
+    :::
+
+3. Open the Inngest Dashboard
+
+    - Visit [http://localhost:8288](http://localhost:8288) in your browser.
+    - Go to the **Apps** section in the sidebar.
+    - You should see your Mastra workflow registered.
+
+    ![Inngest Dashboard](/img/inngest-apps-dashboard.png)
+
+4. Invoke the Workflow
+
+    - Go to the **Functions** section in the sidebar.
+    - Select your Mastra workflow.
+    - Click **Invoke** and use the following input:
+
+    ```json
+    {
+      "data": {
+        "inputData": {
+          "value": 5
+        }
+      }
+    }
+    ```
+
+    ![Inngest Function](/img/inngest-function-dashboard.png)
+
+5. **Monitor the Workflow Execution**
+
+    - Go to the **Runs** tab in the sidebar.
+    - Click on the latest run to see step-by-step execution progress.
+
+    ![Inngest Function Run](/img/inngest-runs-dashboard.png)
+
+### Running the Workflow in Production
+
+:::info[Prerequisites]
+
+- Vercel account and Vercel CLI installed (`npm i -g vercel`)
+- Inngest account
+- Vercel token (recommended: set as environment variable)
+
+:::
+
+1. Add Vercel Deployer to Mastra instance
+
+    ```ts title="src/mastra/index.ts"
+    import { VercelDeployer } from "@mastra/deployer-vercel";
+
+    export const mastra = new Mastra({
+      deployer: new VercelDeployer({
+        teamSlug: "your_team_slug",
+        projectName: "your_project_name",
+        // you can get your vercel token from the vercel dashboard by clicking on the user icon in the top right corner
+        // and then clicking on "Account Settings" and then clicking on "Tokens" on the left sidebar.
+        token: "your_vercel_token",
+      }),
+    });
+    ```
+
+    :::note
+
+    Set your Vercel token in your environment:
+
+    ```sh
+    export VERCEL_TOKEN=your_vercel_token
+    ```
+
+    :::
+
+2. Build the mastra instance
+
+    ```sh
+    npx mastra build
+    ```
+
+3. Deploy to Vercel
+
+    ```sh
+    cd .mastra/output
+    vercel --prod
+    ```
+
+    :::tip
+
+    If you haven't already, log in to Vercel CLI with `vercel login`.
+
+    :::
+
+4. Sync with Inngest Dashboard
+
+    - Go to the [Inngest dashboard](https://app.inngest.com/env/production/apps).
+    - Click **Sync new app with Vercel** and follow the instructions.
+    - You should see your Mastra workflow registered as an app.
+
+    ![Inngest Dashboard](/img/inngest-apps-dashboard-prod.png)
+
+5. Invoke the Workflow
+
+    - In the **Functions** section, select `workflow.increment-workflow`.
+    - Click **All actions** (top right) > **Invoke**.
+    - Provide the following input:
+
+    ```json
+    {
+      "data": {
+        "inputData": {
+          "value": 5
+        }
+      }
+    }
+    ```
+
+    ![Inngest Function Run](/img/inngest-function-dashboard-prod.png)
+
+6.  Monitor Execution
+
+    - Go to the **Runs** tab.
+    - Click the latest run to see step-by-step execution progress.
+
+        ![Inngest Function Run](/img/inngest-runs-dashboard-prod.png)
+
+## Advanced Usage: Adding Custom Inngest Functions
+
+You can serve additional Inngest functions alongside your Mastra workflows by using the optional `functions` parameter in `inngestServe`.
+
+### Creating Custom Functions
+
+First, create your custom Inngest functions:
+
+```ts title="src/inngest/custom-functions.ts"
+import { inngest } from "./inngest";
+
+// Define custom Inngest functions
+export const customEmailFunction = inngest.createFunction(
+  { id: "send-welcome-email" },
+  { event: "user/registered" },
+  async ({ event }) => {
+    // Custom email logic here
+    console.log(`Sending welcome email to ${event.data.email}`);
+    return { status: "email_sent" };
+  },
+);
+
+export const customWebhookFunction = inngest.createFunction(
+  { id: "process-webhook" },
+  { event: "webhook/received" },
+  async ({ event }) => {
+    // Custom webhook processing
+    console.log(`Processing webhook: ${event.data.type}`);
+    return { processed: true };
+  },
+);
+```
+
+### Serving Custom Functions with Workflows
+
+Update your Mastra configuration to include the custom functions:
+
+```ts title="src/mastra/index.ts"
+import { Mastra } from "@mastra/core";
+import { serve as inngestServe } from "@mastra/inngest";
+import { incrementWorkflow } from "./workflows";
+import { inngest } from "./inngest";
+import {
+  customEmailFunction,
+  customWebhookFunction,
+} from "./inngest/custom-functions";
+
+export const mastra = new Mastra({
+  workflows: {
+    incrementWorkflow,
+  },
+  server: {
+    host: "0.0.0.0",
+    apiRoutes: [
+      {
+        path: "/api/inngest",
+        method: "ALL",
+        createHandler: async ({ mastra }) =>
+          inngestServe({
+            mastra,
+            inngest,
+            functions: [customEmailFunction, customWebhookFunction], // Add your custom functions
+          }),
+      },
+    ],
+  },
+});
+```
+
+### Function Registration
+
+When you include custom functions:
+
+1. **Mastra workflows** are automatically converted to Inngest functions with IDs like `workflow.${workflowId}`
+2. **Custom functions** retain their specified IDs (e.g., `send-welcome-email`, `process-webhook`)
+3. **All functions** are served together on the same `/api/inngest` endpoint
+
+This allows you to combine Mastra's workflow orchestration with your existing Inngest functions seamlessly.

package/.docs/raw/guides/deployment/netlify-deployer.mdx

@@ -8,18 +8,18 @@ description: "Learn how to deploy a Mastra application to Netlify using the Mast
 The `NetlifyDeployer` class handles deployment of standalone Mastra applications to Netlify. It manages configuration, deployment, and extends the base [Deployer](/reference/v1/deployer/) class with Netlify specific functionality.
 
 :::warning
-Netlify Functions use an ephemeral filesystem. Remove any usage of [LibSQLStore](/docs/v1/memory/storage/overview) with file URLs from your Mastra configuration. Use in-memory storage (`:memory:`) or external storage providers like Turso, PostgreSQL, or Upstash.
+Netlify Functions use an ephemeral filesystem. Remove any usage of [LibSQLStore](/reference/v1/storage/libsql) with file URLs from your Mastra configuration. Use in-memory storage (`:memory:`) or external storage providers like Turso, PostgreSQL, or Upstash.
 :::
 
 ## Installation
 
-```bash copy
+```bash
 npm install @mastra/deployer-netlify@beta
 ```
 
 ## Usage example
 
-```typescript title="src/mastra/index.ts" copy
+```typescript title="src/mastra/index.ts"
 import { Mastra } from "@mastra/core";
 import { NetlifyDeployer } from "@mastra/deployer-netlify";
 
@@ -48,7 +48,7 @@ Your project is now configured with automatic deployments which occur whenever y
 
 Manual deployments are also possible using the [Netlify CLI](https://docs.netlify.com/cli/get-started/). With the Netlify CLI installed run the following from your project root to deploy your application. You can also run `netlify dev` from your project root to test your Mastra application locally.
 
-```bash copy
+```bash
 netlify deploy --prod
 ```
 

package/.docs/raw/guides/deployment/vercel-deployer.mdx

@@ -8,23 +8,22 @@ description: "Learn how to deploy a Mastra application to Vercel using the Mastr
 The `VercelDeployer` class handles deployment of standalone Mastra applications to Vercel. It manages configuration, deployment, and extends the base [Deployer](/reference/v1/deployer/) class with Vercel specific functionality.
 
 :::warning
-Vercel Functions use an ephemeral filesystem. Remove any usage of [LibSQLStore](/docs/v1/memory/storage/overview) with file URLs from your Mastra configuration. Use in-memory storage (`:memory:`) or external storage providers like Turso, PostgreSQL, or Upstash.
+Vercel Functions use an ephemeral filesystem. Remove any usage of [LibSQLStore](/reference/v1/storage/libsql) with file URLs from your Mastra configuration. Use in-memory storage (`:memory:`) or external storage providers like Turso, PostgreSQL, or Upstash.
 :::
 
 ## Installation
 
-```bash copy
+```bash
 npm install @mastra/deployer-vercel@beta
 ```
 
 ## Usage example
 
-```typescript title="src/mastra/index.ts" showLineNumbers copy
+```typescript title="src/mastra/index.ts"
 import { Mastra } from "@mastra/core";
 import { VercelDeployer } from "@mastra/deployer-vercel";
 
 export const mastra = new Mastra({
-  // ...
   deployer: new VercelDeployer(),
 });
 ```
@@ -41,7 +40,7 @@ The Vercel deployer can write a few high‑value settings into the Vercel Output
 
 Example:
 
-```ts title="src/mastra/index.ts" showLineNumbers copy
+```ts title="src/mastra/index.ts"
 deployer: new VercelDeployer({
   maxDuration: 600,
   memory: 1536,
@@ -67,7 +66,7 @@ Your project is now configured with automatic deployments which occur whenever y
 
 Manual deployments are also possible using the [Vercel CLI](https://vercel.com/docs/cli). With the Vercel CLI installed run the following from your project root to deploy your application.
 
-```bash copy
+```bash
 npm run build && vercel --prod --prebuilt --archive=tgz
 ```