@mastra/mcp-docs-server 1.1.5 → 1.1.6

package/.docs/docs/deployment/mastra-server.md

@@ -0,0 +1,122 @@
+# Deploy a Mastra Server
+
+Mastra compiles your application into a standalone Node.js server that can run on any platform supporting Node.js, Bun, or Deno.
+
+> **Tip:** This guide covers deploying the standalone server generated by `mastra build`. If you need to integrate Mastra into an existing Express or Hono application, see [Server Adapters](https://mastra.ai/docs/server/server-adapters) instead.
+
+## Building your application
+
+Run the build command from your project root:
+
+```bash
+mastra build
+```
+
+This creates a `.mastra` directory containing your production-ready server.
+
+> **Info:** Read the [`mastra build`](https://mastra.ai/reference/cli/mastra) reference for all available flags.
+
+## Build output
+
+After building, Mastra creates the following structure:
+
+```text
+.mastra/
+├── .build/                # Intermediate build artifacts (module maps, analysis)
+└── output/
+    ├── index.mjs          # Server entry point
+    ├── mastra.mjs         # Your bundled Mastra configuration
+    ├── tools.mjs          # Aggregated tool exports
+    ├── tools/             # Individual tool bundles
+    ├── package.json       # Production dependencies
+    ├── node_modules/      # Installed dependencies
+    ├── .npmrc             # Copied from your project (if present)
+    ├── public/            # Static assets (if src/mastra/public exists)
+    └── playground/        # Studio UI (if --studio flag used)
+```
+
+The `output` directory is self-contained. You can copy it to any server and run it directly.
+
+## Running the server
+
+Start the server using the Mastra CLI:
+
+```bash
+mastra start
+```
+
+Or run directly with Node.js:
+
+```bash
+node .mastra/output/index.mjs
+```
+
+The `mastra start` command provides additional features:
+
+- Loads environment variables from `.env.production` and `.env`
+- Provides helpful error messages for missing modules
+- Handles process signals for graceful shutdown
+
+> **Info:** Read the [`mastra start`](https://mastra.ai/reference/cli/mastra) reference for all available flags.
+
+## Build configuration
+
+### Public folder
+
+If a `public` folder exists in your Mastra directory (`src/mastra/public`), its contents are copied to the output directory during build. These files are served as static assets by the server.
+
+### Mastra configuration
+
+The build process respects configuration in your Mastra instance. For server behavior like CORS, timeouts, and middleware, see [server overview](https://mastra.ai/docs/server/mastra-server). For all available options, see the [configuration reference](https://mastra.ai/reference/configuration).
+
+## Build process
+
+The build follows these steps:
+
+1. **Locates entry file**: Finds `index.ts` or `index.js` in your Mastra directory.
+2. **Discovers tools**: Scans for tool files matching `{mastraDir}/tools/**/*.{js,ts}`, excluding test files.
+3. **Analyzes dependencies**: Determines which packages to bundle vs. install externally.
+4. **Bundles code**: Uses Rollup with tree-shaking and optional source maps.
+5. **Generates server**: Creates a Hono-based HTTP server as `index.mjs`.
+6. **Installs dependencies**: Runs `npm install` in the output directory.
+7. **Copies assets**: Copies `public` folder and `.npmrc` if present.
+
+## Environment variables
+
+| Variable             | Description                                                                 |
+| -------------------- | --------------------------------------------------------------------------- |
+| `PORT`               | Server port (default: `4111`)                                               |
+| `MASTRA_STUDIO_PATH` | Path to Studio build directory (default: `./playground`)                    |
+| `MASTRA_SKIP_DOTENV` | Skip loading `.env` files when set                                          |
+| `NODE_OPTIONS`       | Node.js options (e.g., `--max-old-space-size=4096` for build memory issues) |
+
+## Server endpoints
+
+The built server exposes endpoints for health checks, agents, workflows, and more:
+
+| Endpoint            | Description                                                            |
+| ------------------- | ---------------------------------------------------------------------- |
+| `GET /health`       | Health check endpoint, returns `200 OK`                                |
+| `GET /openapi.json` | OpenAPI specification (if `server.build.openAPIDocs` is enabled)       |
+| `GET /swagger-ui`   | Interactive API documentation (if `server.build.swaggerUI` is enabled) |
+
+This list is not exhaustive. To view all endpoints, run `mastra dev` and visit `http://localhost:4111/swagger-ui`.
+
+To add your own endpoints, see [Custom API Routes](https://mastra.ai/docs/server/custom-api-routes).
+
+## Troubleshooting
+
+### Memory errors during build
+
+If you encounter `JavaScript heap out of memory` errors:
+
+```bash
+NODE_OPTIONS="--max-old-space-size=4096" mastra build
+```
+
+## Related
+
+- [Server Overview](https://mastra.ai/docs/server/mastra-server) - Configure server behavior, middleware, and authentication
+- [Server Adapters](https://mastra.ai/docs/server/server-adapters) - Use Express or Hono instead of `mastra build`
+- [Custom API Routes](https://mastra.ai/docs/server/custom-api-routes) - Add custom HTTP endpoints
+- [Configuration Reference](https://mastra.ai/reference/configuration) - Full configuration options

package/.docs/docs/deployment/monorepo.md

@@ -0,0 +1,142 @@
+# Deploy in a Monorepo
+
+Deploying Mastra in a monorepo follows the same process as a standalone application. This guide covers monorepo-specific considerations. For the core build and deployment steps, see [Deploy a Mastra Server](https://mastra.ai/docs/deployment/mastra-server).
+
+## Supported monorepos
+
+Mastra works with:
+
+- npm workspaces
+- pnpm workspaces
+- Yarn workspaces
+- Turborepo
+
+Known limitations:
+
+- Bun workspaces - partial support; known issues
+- Nx - You can use Nx's [supported dependency strategies](https://nx.dev/concepts/decisions/dependency-management) but you need to have `package.json` files inside your workspace packages
+
+## Example structure
+
+In this example, the Mastra application is located at `apps/api`:
+
+```text
+apps/
+├── api/
+│   ├── src/
+│   │   └── mastra/
+│   │       ├── agents/
+│   │       ├── tools/
+│   │       ├── workflows/
+│   │       └── index.ts
+│   ├── package.json
+│   └── tsconfig.json
+└── web/
+packages/
+├── ui/
+└── utils/
+package.json
+```
+
+## Building from a monorepo
+
+Use your monorepo tool to run the build command from the correct package. There's no need for special flags.
+
+Examples:
+
+**npm**:
+
+```bash
+npm run build --workspace=apps/api
+```
+
+**pnpm**:
+
+```bash
+pnpm --filter api run build
+```
+
+**yarn**:
+
+```bash
+yarn workspace api build
+```
+
+**Turborepo**:
+
+```bash
+turbo run build --filter=api
+```
+
+Your package's `build` script should run `mastra build`:
+
+```json
+{
+  "scripts": {
+    "build": "mastra build"
+  }
+}
+```
+
+## Workspace packages
+
+When your Mastra application imports from other workspace packages, Mastra handles this automatically:
+
+- If the package is pre-compiled (e.g., built with `tsc` or `tsdown`), Mastra imports the compiled JavaScript
+- If the package contains uncompiled TypeScript, Mastra transpiles it during the build
+
+For most setups, this works without configuration. If you encounter issues with workspace package imports, add the package to [`transpilePackages`](https://mastra.ai/reference/configuration):
+
+```typescript
+export const mastra = new Mastra({
+  bundler: {
+    transpilePackages: ['@my-org/utils'],
+  },
+})
+```
+
+## Environment variables
+
+Store `.env` files in the Mastra application directory (e.g., `apps/api/.env`), not the monorepo root.
+
+## Deployment configuration
+
+When deploying to cloud providers, ensure the correct package is selected as the deploy target. Selecting the monorepo root instead of the application directory (e.g., `apps/api`) is a common mistake.
+
+Most providers let you specify the root directory in their dashboard or configuration file.
+
+### Mastra Cloud
+
+The image below shows how to select `apps/api` as the project root when deploying to [Mastra Cloud](https://mastra.ai/docs/mastra-cloud/overview). While the interface may differ between providers, the configuration remains the same.
+
+![Deployment configuration](/assets/images/monorepo-mastra-cloud-6bd3d30cb0ef7c255c8d8bb43aeff4ec.jpg)
+
+## Dependency management
+
+Keep dependencies consistent to avoid version conflicts and build errors:
+
+- Use a **single lockfile** at the monorepo root so all packages resolve the same versions
+- Align versions of **shared libraries** (like Mastra or frameworks) to prevent duplicates
+
+## Troubleshooting
+
+### Workspace package not found
+
+If Mastra can't resolve a workspace package, ensure:
+
+- The package is listed in your `package.json` dependencies
+- Your lockfile is up to date (`pnpm install`, `npm install`, etc.)
+- The package has a valid `main` or `exports` field in its `package.json`
+
+### TypeScript errors from workspace packages
+
+If you see type errors from uncompiled workspace packages, either:
+
+- Build the package first (recommended for faster Mastra builds)
+- Add the package to [`transpilePackages`](https://mastra.ai/reference/configuration) in your Mastra config
+
+## Related
+
+- [Deploy a Mastra Server](https://mastra.ai/docs/deployment/mastra-server) - Core build and deployment guide
+- [Configuration Reference](https://mastra.ai/reference/configuration) - `bundler.transpilePackages` and other options
+- [CLI Reference](https://mastra.ai/reference/cli/mastra) - Build command flags

package/.docs/docs/deployment/overview.md

@@ -0,0 +1,62 @@
+# Deployment Overview
+
+Mastra applications can be deployed to any Node.js-compatible environment. You can deploy a Mastra server, integrate with an existing web framework, deploy to cloud providers, or use Mastra Cloud for managed hosting.
+
+## Runtime support
+
+Mastra can run against any of these runtime environments:
+
+- Node.js `v22.13.0` or later
+- Bun
+- Deno
+- Cloudflare
+
+## Deployment Options
+
+### Mastra Server
+
+Mastra provides a [server](https://mastra.ai/docs/server/mastra-server) powered by Hono that can be deployed independently. Use the `mastra build` command to build your application and deploy the output to your preferred VM, container, or PaaS platform.
+
+Use this option when you need full control over your infrastructure, long-running processes, or WebSocket connections. The [Mastra server deployment guide](https://mastra.ai/docs/deployment/mastra-server) provides more details.
+
+### Monorepo
+
+Deploy a Mastra server as part of a monorepo setup, following the same approach as standalone deployment.
+
+Read about [monorepo deployment](https://mastra.ai/docs/deployment/monorepo).
+
+### Cloud Providers
+
+Mastra applications can be deployed to cloud providers and serverless platforms. Mastra includes optional built-in deployers for Vercel, Netlify, and Cloudflare to automate the build and deployment process.
+
+Use this option for auto-scaling, minimal infrastructure management, or when you're already using one of these platforms.
+
+- [Amazon EC2](https://mastra.ai/guides/deployment/amazon-ec2)
+- [AWS Lambda](https://mastra.ai/guides/deployment/aws-lambda)
+- [Azure App Services](https://mastra.ai/guides/deployment/azure-app-services)
+- [Cloudflare](https://mastra.ai/guides/deployment/cloudflare)
+- [Digital Ocean](https://mastra.ai/guides/deployment/digital-ocean)
+- [Netlify](https://mastra.ai/guides/deployment/netlify)
+- [Vercel](https://mastra.ai/guides/deployment/vercel)
+
+### Web Framework
+
+When Mastra is integrated with a web framework, it deploys alongside your application using the framework's standard deployment process. The guides below cover framework-specific configuration requirements for deployment.
+
+Use these guides when adding Mastra to an existing Next.js or Astro application.
+
+- [With Next.js on Vercel](https://mastra.ai/docs/deployment/web-framework)
+- [With Astro on Vercel](https://mastra.ai/docs/deployment/web-framework)
+- [With Astro on Netlify](https://mastra.ai/docs/deployment/web-framework)
+
+### Mastra Cloud
+
+We're building Mastra Cloud to be the easiest place to deploy and observe your Mastra agents. It's currently in beta.
+
+Learn more in the [Mastra Cloud docs](https://mastra.ai/docs/mastra-cloud/overview).
+
+## Workflow Runners
+
+Mastra workflows run using the built-in execution engine by default. For production workloads requiring managed infrastructure, workflows can also be deployed to specialized platforms like [Inngest](https://www.inngest.com) that provide step memoization, automatic retries, and real-time monitoring.
+
+Visit the [Workflow Runners guide](https://mastra.ai/docs/deployment/workflow-runners) for execution options and the [Inngest deployment guide](https://mastra.ai/guides/deployment/inngest) for setup instructions.

package/.docs/docs/deployment/studio.md

@@ -0,0 +1,239 @@
+# Deploying Studio
+
+[Studio](https://mastra.ai/docs/getting-started/studio) provides an interactive UI for building and testing your agents. It's a React-based Single Page Application (SPA) that runs in the browser and connects to a running [Mastra server](https://mastra.ai/docs/deployment/mastra-server).
+
+There are two primary ways of deploying Studio:
+
+- [Mastra Cloud](https://mastra.ai/docs/mastra-cloud/overview) hosts Studio for you and allows you to share access with your team via link
+- You can self-host Studio on your own infrastructure, either alongside your Mastra server or separately as a standalone SPA
+
+On this page you'll learn how to deploy Studio on your own infrastructure. As the finer details of deployment can vary widely based on your needs and setup, we'll cover the general principles and options available to you.
+
+## Fundamentals
+
+The easiest way to run Studio is the [`mastra studio`](https://mastra.ai/reference/cli/mastra) command.
+
+Whereas `mastra dev` runs both Studio and an API for development purposes, the purpose of `mastra studio` is to serve a standalone, static UI that connects to an already-running Mastra server. This allows you to deploy Studio on its own, separate from the Mastra server, if desired.
+
+Open a terminal and install the `mastra` CLI globally:
+
+**npm**:
+
+```bash
+npm install -g mastra
+```
+
+**pnpm**:
+
+```bash
+pnpm add -g mastra
+```
+
+**Yarn**:
+
+```bash
+yarn global add mastra
+```
+
+**Bun**:
+
+```bash
+bun add --global mastra
+```
+
+Run the `mastra studio` command:
+
+```bash
+mastra studio
+```
+
+Open [localhost:3000](http://localhost:3000) in your browser to see the Studio UI. By default, it will attempt to connect to a Mastra server running at `http://localhost:4111`. If it doesn't find one there, you'll see a form where you can enter your Mastra instance URL and API prefix.
+
+The command uses Node's built-in `http` module and [`serve-handler`](https://www.npmjs.com/package/serve-handler) to serve the static files.
+
+## Running a server
+
+Running `mastra studio` as a long-running process is no different from running any other Node.js service. All the best practices, tools, and options for deployment apply here as well. You can use process managers like PM2, use Docker, or cloud services that support Node.js applications. You'll need to ensure CORS is configured correctly and errors are monitored, just like with any web service.
+
+> **Warning:** Once Studio is connected to your Mastra server, it has full access to your agents, workflows, and tools. Be sure to secure it properly in production (e.g. behind authentication, VPN, etc.) to prevent unauthorized access.
+
+### Alongside your API
+
+Alternatively, you can serve Studio alongside your [Mastra server](https://mastra.ai/docs/deployment/mastra-server). This way you only have one service to deploy and manage.
+
+To do this, run `mastra build` with the `--studio` flag:
+
+```bash
+mastra build --studio
+```
+
+It'll create a `.mastra/output/studio` folder with the built Studio assets. By defining the `MASTRA_STUDIO_PATH` environment variable, the Mastra server can serve the Studio UI, too.
+
+```bash
+MASTRA_STUDIO_PATH=.mastra/output/studio node .mastra/output/index.mjs
+```
+
+## Using a CDN
+
+Currently, you can't directly deploy the built Studio assets to a CDN, as the UI relies on some dynamic configuration. With a bit of extra setup, you can create a standalone SPA out of the built assets and deploy it to any static hosting service like Netlify, Vercel, etc.
+
+Follow the example below to create a SPA using Vite.
+
+1. Create a new folder and initialize a new Node.js project:
+
+   **npm**:
+
+   ```bash
+   mkdir studio-spa
+   cd studio-spa
+   npm init
+   ```
+
+   **pnpm**:
+
+   ```bash
+   mkdir studio-spa
+   cd studio-spa
+   pnpm init
+   ```
+
+   **Yarn**:
+
+   ```bash
+   mkdir studio-spa
+   cd studio-spa
+   yarn init
+   ```
+
+   **Bun**:
+
+   ```bash
+   mkdir studio-spa
+   cd studio-spa
+   bun init
+   ```
+
+2. Install `vite` and `mastra` as dependencies:
+
+   **npm**:
+
+   ```bash
+   npm install vite mastra
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm add vite mastra
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn add vite mastra
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun add vite mastra
+   ```
+
+3. Add a build script to your `package.json`:
+
+   ```json
+   {
+     "scripts": {
+       "build": "vite build"
+     }
+   }
+   ```
+
+4. Create a placeholder `index.html` file:
+
+   ```html
+   <!doctype html>
+   <html>
+     <head></head>
+     <body></body>
+   </html>
+   ```
+
+5. Create a `vite.config.js` file. It copies the built Studio assets to the `dist` folder and replaces any `%%PLACEHOLDER%%` values in the HTML with environment variable values.
+
+   ```js
+   import { defineConfig, loadEnv } from 'vite'
+   import { readFileSync, cpSync, writeFileSync } from 'node:fs'
+   import { resolve, join } from 'node:path'
+
+   const studioDir = resolve(import.meta.dirname, 'node_modules/mastra/dist/studio')
+
+   export default defineConfig(({ mode }) => {
+     const env = loadEnv(mode, process.cwd(), 'MASTRA_')
+
+     return {
+       plugins: [
+         {
+           name: 'mastra-studio',
+           closeBundle() {
+             const outDir = resolve(import.meta.dirname, 'dist')
+             cpSync(studioDir, outDir, { recursive: true })
+
+             const indexPath = join(outDir, 'index.html')
+             const html = readFileSync(indexPath, 'utf-8')
+             writeFileSync(
+               indexPath,
+               html.replaceAll(/%%(\w+)%%/g, (_, key) => env[key] ?? ''),
+             )
+           },
+         },
+       ],
+       build: {
+         emptyOutDir: true,
+       },
+     }
+   })
+   ```
+
+6. Create a `.env` file with the necessary environment variables.
+
+   ```env
+   MASTRA_SERVER_HOST=localhost
+   MASTRA_SERVER_PORT=4111
+   MASTRA_SERVER_PROTOCOL=http
+   MASTRA_API_PREFIX=/api
+   MASTRA_STUDIO_BASE_PATH=
+   MASTRA_TELEMETRY_DISABLED=true
+   MASTRA_HIDE_CLOUD_CTA=false
+   MASTRA_CLOUD_API_ENDPOINT=
+   MASTRA_EXPERIMENTAL_FEATURES=false
+   MASTRA_REQUEST_CONTEXT_PRESETS=
+   ```
+
+7. Run the build script to generate the static files in the `dist` folder:
+
+   **npm**:
+
+   ```bash
+   npm run build
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm run build
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn build
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun run build
+   ```
+
+8. Point your hosting provider to the `dist` folder and deploy!

package/.docs/docs/deployment/web-framework.md

@@ -0,0 +1,52 @@
+# Deploy with a Web Framework
+
+When Mastra is integrated with a web framework, it deploys alongside your application using the framework's standard deployment process. Follow the instructions below to ensure your Mastra integration deploys correctly.
+
+> **Warning:** If you're deploying to a cloud provider, remove any usage of [LibSQLStore](https://mastra.ai/reference/storage/libsql) from your Mastra configuration. LibSQLStore requires filesystem access and is not compatible with serverless platforms.
+
+Integration guides:
+
+- [With Next.js](https://mastra.ai/guides/getting-started/next-js)
+- [With Astro](https://mastra.ai/guides/getting-started/astro)
+
+## With Next.js on Vercel
+
+If you've integrated Mastra with Next.js [by following our guide](https://mastra.ai/guides/getting-started/next-js) and plan to deploy to Vercel, add `serverExternalPackages: ["@mastra/*"]` to your `next.config.ts`:
+
+```typescript
+import type { NextConfig } from 'next'
+
+const nextConfig: NextConfig = {
+  serverExternalPackages: ['@mastra/*'],
+}
+
+export default nextConfig
+```
+
+## With Astro on Vercel
+
+If you've integrated Mastra with Astro [by following our guide](https://mastra.ai/guides/getting-started/astro) and plan to deploy to Vercel, add the Vercel adapter and server output to your `astro.config.mjs`:
+
+```javascript
+import { defineConfig } from 'astro/config'
+import vercel from '@astrojs/vercel'
+
+export default defineConfig({
+  adapter: vercel(),
+  output: 'server',
+})
+```
+
+## With Astro on Netlify
+
+If you've integrated Mastra with Astro [by following our guide](https://mastra.ai/guides/getting-started/astro) and plan to deploy to Netlify, add the Netlify adapter and server output to your `astro.config.mjs`:
+
+```javascript
+import { defineConfig } from 'astro/config'
+import netlify from '@astrojs/netlify'
+
+export default defineConfig({
+  adapter: netlify(),
+  output: 'server',
+})
+```

package/.docs/docs/deployment/workflow-runners.md

@@ -0,0 +1,9 @@
+# Workflow Runners
+
+Mastra [workflows](https://mastra.ai/docs/workflows/overview) can be executed using the built-in workflow runner or deployed to specialized workflow execution platforms that handle orchestration, monitoring, and reliability.
+
+## Inngest
+
+Inngest is a developer platform for running background workflows without managing infrastructure. Mastra workflows can be deployed to Inngest, which provides step memoization, automatic retries, real-time monitoring, and suspend/resume capabilities.
+
+Visit the [Inngest deployment guide](https://mastra.ai/guides/deployment/inngest) for setup instructions and the [Inngest workflow example](https://github.com/mastra-ai/mastra/tree/main/examples/inngest) for a complete implementation.

package/.docs/docs/evals/built-in-scorers.md

@@ -0,0 +1,47 @@
+# Built-in Scorers
+
+Mastra provides a comprehensive set of built-in scorers for evaluating AI outputs. These scorers are optimized for common evaluation scenarios and are ready to use in your agents and workflows.
+
+To create your own scorers, see the [Custom Scorers](https://mastra.ai/docs/evals/custom-scorers) guide.
+
+## Available scorers
+
+### Accuracy and reliability
+
+These scorers evaluate how correct, truthful, and complete your agent's answers are:
+
+- [`answer-relevancy`](https://mastra.ai/reference/evals/answer-relevancy): Evaluates how well responses address the input query (`0-1`, higher is better)
+- [`answer-similarity`](https://mastra.ai/reference/evals/answer-similarity): Compares agent outputs against ground-truth answers for CI/CD testing using semantic analysis (`0-1`, higher is better)
+- [`faithfulness`](https://mastra.ai/reference/evals/faithfulness): Measures how accurately responses represent provided context (`0-1`, higher is better)
+- [`hallucination`](https://mastra.ai/reference/evals/hallucination): Detects factual contradictions and unsupported claims (`0-1`, lower is better)
+- [`completeness`](https://mastra.ai/reference/evals/completeness): Checks if responses include all necessary information (`0-1`, higher is better)
+- [`content-similarity`](https://mastra.ai/reference/evals/content-similarity): Measures textual similarity using character-level matching (`0-1`, higher is better)
+- [`textual-difference`](https://mastra.ai/reference/evals/textual-difference): Measures textual differences between strings (`0-1`, higher means more similar)
+- [`tool-call-accuracy`](https://mastra.ai/reference/evals/tool-call-accuracy): Evaluates whether the LLM selects the correct tool from available options (`0-1`, higher is better)
+- [`prompt-alignment`](https://mastra.ai/reference/evals/prompt-alignment): Measures how well agent responses align with user prompt intent, requirements, completeness, and format (`0-1`, higher is better)
+
+### Context quality
+
+These scorers evaluate the quality and relevance of context used in generating responses:
+
+- [`context-precision`](https://mastra.ai/reference/evals/context-precision): Evaluates context relevance and ranking using Mean Average Precision, rewarding early placement of relevant context (`0-1`, higher is better)
+- [`context-relevance`](https://mastra.ai/reference/evals/context-relevance): Measures context utility with nuanced relevance levels, usage tracking, and missing context detection (`0-1`, higher is better)
+
+> tip Context Scorer Selection
+>
+> - Use **Context Precision** when context ordering matters and you need standard IR metrics (ideal for RAG ranking evaluation)
+> - Use **Context Relevance** when you need detailed relevance assessment and want to track context usage and identify gaps
+>
+> Both context scorers support:
+>
+> - **Static context**: Pre-defined context arrays
+> - **Dynamic context extraction**: Extract context from runs using custom functions (ideal for RAG systems, vector databases, etc.)
+
+### Output quality
+
+These scorers evaluate adherence to format, style, and safety requirements:
+
+- [`tone-consistency`](https://mastra.ai/reference/evals/tone-consistency): Measures consistency in formality, complexity, and style (`0-1`, higher is better)
+- [`toxicity`](https://mastra.ai/reference/evals/toxicity): Detects harmful or inappropriate content (`0-1`, lower is better)
+- [`bias`](https://mastra.ai/reference/evals/bias): Detects potential biases in the output (`0-1`, lower is better)
+- [`keyword-coverage`](https://mastra.ai/reference/evals/keyword-coverage): Assesses technical terminology usage (`0-1`, higher is better)