@mastra/mcp-docs-server 1.1.4 → 1.1.5

package/.docs/guides/deployment/aws-lambda.md

@@ -1,248 +0,0 @@
-# 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.
-
-> **Note:** 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](https://mastra.ai/guides/getting-started/quickstart)
-
-## 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
-
-> **Warning:** AWS Lambda uses an ephemeral file system, meaning that any files written to the file system are short-lived and may be lost. Remove any usage of [LibSQLStore](https://mastra.ai/reference/storage/libsql) with file URLs from your Mastra configuration. Use in-memory storage (`:memory:`) or external storage providers like Turso, PostgreSQL, or Upstash.
-
-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
-import { LibSQLStore } from "@mastra/libsql";
-
-const storage = new LibSQLStore({
-  id: 'mastra-storage',
-  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
-import { LibSQLStore } from "@mastra/libsql";
-
-const storage = new LibSQLStore({
-  id: 'mastra-storage',
-  url: "libsql://your-database.turso.io", // External Turso database
-  authToken: process.env.TURSO_AUTH_TOKEN,
-});
-```
-
-For more memory configuration options, see the [Memory documentation](https://mastra.ai/docs/memory/overview).
-
-## Creating a Dockerfile
-
-Create a `Dockerfile` in your Mastra project root directory:
-
-```dockerfile
-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", ".mastra/output/index.mjs"]
-```
-
-## Building and Deploying
-
-1. Set up your environment variables for the deployment process:
-
-   ```bash
-   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)
-   ```
-
-2. Build your Docker image locally:
-
-   ```bash
-   docker build -t "$PROJECT_NAME" .
-   ```
-
-3. Create an Amazon ECR repository to store your Docker image:
-
-   ```bash
-   aws ecr create-repository --repository-name "$PROJECT_NAME" --region "$AWS_REGION"
-   ```
-
-4. Log in to Amazon ECR:
-
-   ```bash
-   aws ecr get-login-password --region "$AWS_REGION" | docker login --username AWS --password-stdin "$AWS_ACCOUNT_ID.dkr.ecr.$AWS_REGION.amazonaws.com"
-   ```
-
-5. Tag your image with the ECR repository URI and push it:
-
-   ```bash
-   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
-   ```
-
-6. 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`)
-
-7. 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` (`x-amzn-request-context` is also required when used with services like Cloudfront/API Gateway)
-      - **Allow-Methods**: `*` (audit and restrict in production)
-
-   5. Click **Save**
-
-8. 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
-
-9. 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)
-
-## 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](https://mastra.ai/docs/deployment/mastra-server).
-
-## Connecting your client
-
-Update your client application to use the Lambda function URL:
-
-```typescript
-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](https://mastra.ai/reference/client-js/mastra-client)
-- [AWS Lambda documentation](https://docs.aws.amazon.com/lambda/)
-- [AWS Lambda Web Adapter](https://github.com/awslabs/aws-lambda-web-adapter)

package/.docs/guides/deployment/azure-app-services.md

@@ -1,114 +0,0 @@
-# Azure App Services
-
-Deploy your Mastra applications to Azure App Services.
-
-> **Note:** 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](https://mastra.ai/guides/getting-started/quickstart)
-
-> **Warning:** Azure App Services uses an ephemeral filesystem for some pricing tiers. Remove any usage of [LibSQLStore](https://mastra.ai/reference/storage/libsql) with file URLs from your Mastra configuration. Use in-memory storage (`:memory:`) or external storage providers like Turso, PostgreSQL, or Upstash.
-
-## Prerequisites
-
-- An [Azure account](https://azure.microsoft.com/) with an active subscription
-- A [GitHub repository](https://github.com/) containing your Mastra application
-- Your Mastra application should be created using `npx create-mastra@latest`
-
-## Deployment Steps
-
-1. Create a new App service:
-
-   - Log in to the [Azure Portal](https://portal.azure.com)
-   - Navigate to **[App Services](https://docs.microsoft.com/en-us/azure/app-service/)** or search for it in the top search bar
-   - Click **Create** to create a new App Service
-   - In the drop-down, select **Web App**
-
-2. Configure app service settings:
-
-   - **Subscription**: Select your Azure subscription
-   - **Resource Group**: Create a new resource group or select an existing one
-   - **Instance name**: Enter a unique name for your app (this will be part of your URL)
-   - **Publish**: Select **Code**
-   - **Runtime stack**: Select **Node 22 LTS**
-   - **Operating System**: Select **Linux**
-   - **Region**: Choose a region close to your users
-   - **Linux Plan**: You may have the option of choosing a plan depending on the region you chose, pick an appropriate one for your needs.
-   - Click **Review + Create**
-   - Wait for validation to complete, then click **Create**
-
-3. Wait for deployment:
-
-   - Wait for the deployment to complete
-   - Once finished, click **Go to resource** under the next steps section
-
-4. Before setting up deployment, configure your environment variables:
-
-   - Navigate to **Settings** > **Environment variables** in the left sidebar
-
-   - Add your required environment variables such as:
-
-     - Model provider API keys (e.g., `OPENAI_API_KEY`)
-     - Database connection strings
-     - Any other configuration values your Mastra application requires
-
-   - Click **Apply** to save the changes
-
-5. Setup GitHub deployment:
-
-   - Navigate to **Deployment Center** in the left sidebar
-   - Select **GitHub** as your source
-   - Sign in to GitHub if you're not already authenticated with Azure
-   - In this example, we will keep [GitHub Actions](https://docs.github.com/en/actions) as our provider
-   - Select your organization, repository, and branch
-   - Azure will generate a GitHub workflow file and you can preview it before proceeding
-   - Click **Save** (the save button is located at the top of the page)
-
-6. After Azure creates the workflow, it will trigger a GitHub Actions run and merge the workflow file into your branch. **Cancel this initial run** as it will fail without the necessary modifications.
-
-   > **Warning:** The default workflow generated by Azure will fail for Mastra applications and needs to be modified.
-
-   Pull the latest changes to your local repository and modify the generated workflow file (`.github/workflows/main_<your-app-name>.yml`):
-
-   1. **Update the build step**: Find the step named "npm install, build, and test" and:
-
-      - Change the step name to "npm install and build"
-      - If you haven't set up proper tests in your Mastra application, remove the `npm test` command from the run section as the default test script will fail and disrupt deployment. If you have working tests, you can keep the test command.
-
-   2. **Update the zip artifact step**: Find the "Zip artifact for deployment" step and replace the zip command with:
-
-      ```yaml
-      run: (cd .mastra/output && zip ../../release.zip -r .)
-      ```
-
-      This ensures only the build outputs from `.mastra/output` are included in the deployment package.
-
-7. Deploy your changes:
-
-   - Commit and push your workflow modifications
-   - The build will be automatically triggered in the **Deployment Center** in your Azure dashboard
-   - Monitor the deployment progress until it completes successfully
-
-8. Access your deployed application:
-
-   - Once the build is successful, wait a few moments for the application to start
-   - Access your deployed application using the default URL provided in the **Overview** tab in the Azure portal
-   - Your application will be available at `https://<your-app-name>.azurewebsites.net`
-
-## 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](https://mastra.ai/reference/client-js/mastra-client) for more information.
-
-```typescript
-import { MastraClient } from "@mastra/client-js";
-
-const mastraClient = new MastraClient({
-  baseUrl: "https://<your-app-name>.azurewebsites.net",
-});
-```
-
-## Next steps
-
-- [Mastra Client SDK](https://mastra.ai/reference/client-js/mastra-client)
-- [Configure custom domains](https://docs.microsoft.com/en-us/azure/app-service/app-service-web-tutorial-custom-domain)
-- [Enable HTTPS](https://docs.microsoft.com/en-us/azure/app-service/configure-ssl-bindings)
-- [Azure App Service documentation](https://docs.microsoft.com/en-us/azure/app-service/)

package/.docs/guides/deployment/cloudflare.md

@@ -1,99 +0,0 @@
-# Deploy Mastra to Cloudflare
-
-Use `@mastra/deployer-cloudflare` to deploy your Mastra server to Cloudflare Workers. The deployer bundles your code and generates a `wrangler.jsonc` file conforming to Cloudflare's [wrangler configuration](https://developers.cloudflare.com/workers/wrangler/configuration/), ready to deploy with no additional configuration.
-
-> **Info:** If you're using a [server adapter](https://mastra.ai/docs/server/server-adapters) or [web framework](https://mastra.ai/docs/deployment/web-framework), deploy the way you normally would for that framework.
-
-## Before you begin
-
-You'll need a [Mastra application](https://mastra.ai/guides/getting-started/quickstart) and a [Cloudflare](https://cloudflare.com/) account.
-
-Cloudflare Workers use an ephemeral filesystem, so any storage you configure (including observability storage) must be hosted externally. If you're using [LibSQLStore](https://mastra.ai/reference/storage/libsql) with a file URL, switch to a remotely hosted database.
-
-## Installation
-
-Add the `@mastra/deployer-cloudflare` package to your project:
-
-**npm**:
-
-```bash
-npm install @mastra/deployer-cloudflare@latest
-```
-
-**pnpm**:
-
-```bash
-pnpm add @mastra/deployer-cloudflare@latest
-```
-
-**Yarn**:
-
-```bash
-yarn add @mastra/deployer-cloudflare@latest
-```
-
-**Bun**:
-
-```bash
-bun add @mastra/deployer-cloudflare@latest
-```
-
-Import [`CloudflareDeployer`](https://mastra.ai/reference/deployer/cloudflare) and set it as the deployer in your Mastra configuration:
-
-```typescript
-import { Mastra } from "@mastra/core";
-import { CloudflareDeployer } from "@mastra/deployer-cloudflare";
-
-export const mastra = new Mastra({
-  deployer: new CloudflareDeployer({
-    name: "your-project-name",
-    vars: {
-      NODE_ENV: "production",
-    },
-  }),
-});
-```
-
-In order to test your Cloudflare Worker locally, also install the [`wrangler` CLI](https://developers.cloudflare.com/workers/wrangler/install-and-update/):
-
-**npm**:
-
-```bash
-npm install -D wrangler
-```
-
-**pnpm**:
-
-```bash
-pnpm add -D wrangler
-```
-
-**Yarn**:
-
-```bash
-yarn add --dev wrangler
-```
-
-**Bun**:
-
-```bash
-bun add --dev wrangler
-```
-
-## Usage
-
-After setting up your project, push it to your remote Git provider of choice (e.g. GitHub).
-
-1. Connect your repository to Cloudflare. On the "Workers & Pages" dashboard, select **Create application** and choose your Git provider in the next step. Continue with the setup process and select the repository you want to deploy.
-
-   > **Note:** Remember to set your environment variables needed to run your application (e.g. your [model provider](https://mastra.ai/models/providers) API key).
-
-2. Once you're ready, click the **Deploy** button and wait for the first deployment to complete.
-
-3. Try out your newly deployed function by going to `https://<your-project-name>.<slug>.workers.dev/api/agents`. You should get a JSON response listing all available agents.
-
-   Since the [Mastra server](https://mastra.ai/docs/server/mastra-server) prefixes every API endpoint with `/api`, you have to add it to your URLs when making requests.
-
-4. You can now call your Mastra endpoints over HTTP.
-
-   > **Note:** Set up [authentication](https://mastra.ai/docs/server/auth) before exposing your endpoints publicly.

package/.docs/guides/deployment/digital-ocean.md

@@ -1,168 +0,0 @@
-# Deploy Mastra to Digital Ocean
-
-This guide covers Digital Ocean's App Platform and Droplets. Each of these offerings has its own set of strengths and is suited for different types of projects and developer expertise. Read [Digital Ocean's comparison](https://www.digitalocean.com/community/conceptual-articles/digitalocean-app-platform-vs-doks-vs-droplets) to understand the differences and choose the best option for your project.
-
-> **Info:** This guide covers deploying the [Mastra server](https://mastra.ai/docs/server/mastra-server). If you're using a [server adapter](https://mastra.ai/docs/server/server-adapters) or [web framework](https://mastra.ai/docs/deployment/web-framework), deploy the way you normally would for that framework.
-
-## Before you begin
-
-You'll need a [Mastra application](https://mastra.ai/guides/getting-started/quickstart) and a [Digital Ocean](https://www.digitalocean.com/) account.
-
-The **App Platform** uses an ephemeral filesystem, so any storage you configure (including observability storage) must be hosted externally. If you're using [LibSQLStore](https://mastra.ai/reference/storage/libsql) with a file URL, switch to a remotely hosted database.
-
-## App Platform
-
-After setting up your project, push it to your remote Git provider of choice (e.g. GitHub).
-
-1. Follow the official [App Platform quickstart](https://docs.digitalocean.com/products/app-platform/getting-started/quickstart/#create-an-app). It'll guide you through connecting your repository, selecting the branch to deploy from, and configuring the source directory if necessary.
-
-2. Make sure that a "Node.js" build is detected. You'll need to configure a build command. Set it based on your package manager:
-
-   **npm**:
-
-   ```bash
-   npm run build
-   ```
-
-   **pnpm**:
-
-   ```bash
-   pnpm run build
-   ```
-
-   **Yarn**:
-
-   ```bash
-   yarn build
-   ```
-
-   **Bun**:
-
-   ```bash
-   bun run build
-   ```
-
-3. Add any required environment variables for your Mastra application. This includes API keys, database URLs, and other configuration values.
-
-4. Your app will be built and deployed automatically. Digital Ocean will provide you with a URL to access your deployed application.
-
-5. You can now call your Mastra endpoints over HTTP.
-
-   > **Warning:** Set up [authentication](https://mastra.ai/docs/server/auth) before exposing your endpoints publicly.
-
-## Droplets
-
-### Prerequisites
-
-- A Droplet running Ubuntu 24.04 LTS or later
-- A domain name with an A record pointing to your droplet
-- 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 22.13.0 or later installed on your droplet
-
-### Deploy
-
-After setting up your project, push it to your remote Git provider of choice (e.g. GitHub). Connect to your Droplet and make sure `git` is installed.
-
-1. Clone your repository:
-
-   **Public Repository**:
-
-   ```bash
-   git clone https://github.com/<your-username>/<your-repository>.git
-   ```
-
-   **Private Repository**:
-
-   ```bash
-   git clone https://<your-username>:<your-personal-access-token>@github.com/<your-username>/<your-repository>.git
-   ```
-
-   Navigate to the repository directory:
-
-   ```bash
-   cd "<your-repository>"
-   ```
-
-2. Install the project dependencies:
-
-   **npm**:
-
-   ```bash
-   npm install
-   ```
-
-   **pnpm**:
-
-   ```bash
-   pnpm install
-   ```
-
-   **Yarn**:
-
-   ```bash
-   yarn install
-   ```
-
-   **Bun**:
-
-   ```bash
-   bun install
-   ```
-
-3. Set the required environment variables for your Mastra application. Create a `.env` file in the root of your project:
-
-   ```bash
-   touch .env
-   ```
-
-   Edit the `.env` file and add your environment variables:
-
-   ```bash
-   OPENAI_API_KEY=your-api-key
-   ```
-
-4. Build the project:
-
-   **npm**:
-
-   ```bash
-   npm run build
-   ```
-
-   **pnpm**:
-
-   ```bash
-   pnpm run build
-   ```
-
-   **Yarn**:
-
-   ```bash
-   yarn build
-   ```
-
-   **Bun**:
-
-   ```bash
-   bun run build
-   ```
-
-   This will create a production build of Mastra's server in the `.mastra/output` directory.
-
-5. You can run the [Mastra Server](https://mastra.ai/docs/deployment/mastra-server) by running the `mastra start` command:
-
-   ```bash
-   mastra start
-   ```
-
-   > **Info:** Your Mastra application will run on port 4111 by default. Ensure your reverse proxy is configured to forward requests to this port.
-
-6. You can now call your Mastra endpoints over HTTP.
-
-   > **Warning:** Set up [authentication](https://mastra.ai/docs/server/auth) before exposing your endpoints publicly.
-
-## Related
-
-- [Digital Ocean App Platform](https://docs.digitalocean.com/products/app-platform/)
-- [Digital Ocean Droplets](https://docs.digitalocean.com/products/droplets/)