@mastra/mcp-docs-server 1.0.0-beta.8 → 1.0.0

package/.docs/raw/deployment/monorepo.mdx

@@ -1,15 +1,34 @@
 ---
-title: "Monorepo Deployment | Deployment"
+title: "Deploy in a Monorepo | Deployment"
 description: Learn how to deploy Mastra applications that are part of a monorepo setup
+packages:
+  - "@mastra/deployer"
 ---
 
-# Monorepo Deployment
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
 
-Deploying Mastra in a monorepo follows the same approach as deploying a standalone application. While some [Cloud](./cloud-providers/) or [Serverless Platform](./cloud-providers/) providers may introduce extra requirements, the core setup is the same.
+# Deploy in a Monorepo
 
-## Example 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](/docs/v1/deployment/mastra-server).
 
-In this example, the Mastra application is located at `apps/api`.
+## 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`:
 
 ```
 apps/
@@ -29,69 +48,114 @@ packages/
 package.json
 ```
 
-## Environment variables
+## 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:
 
-Environment variables like `OPENAI_API_KEY` should be stored in an `.env` file at the root of the Mastra application `(apps/api)`, for example:
+<Tabs>
+<TabItem value="npm" label="npm">
 
+```bash
+npm run build --workspace=apps/api
 ```
-api/
-├── src/
-│   └── mastra/
-├── .env
-├── package.json
-└── tsconfig.json
+
+</TabItem>
+
+<TabItem value="pnpm" label="pnpm">
+
+```bash
+pnpm --filter api run build
 ```
 
-## Deployment configuration
+</TabItem>
 
-The image below shows how to select `apps/api` as the project root when deploying to [Mastra Cloud](./mastra-cloud/overview). While the interface may differ between providers, the configuration remains the same.
+<TabItem value="yarn" label="yarn">
 
-![Deployment configuration](/img/monorepo/monorepo-mastra-cloud.jpg)
+```bash
+yarn workspace api build
+```
 
-## Dependency management
+</TabItem>
 
-In a monorepo, keep dependencies consistent to avoid version conflicts and build errors.
+<TabItem value="turborepo" label="Turborepo">
 
-- Use a **single lockfile** at the project root so all packages resolve the same versions.
-- Align versions of **shared libraries** (like Mastra or frameworks) to prevent duplicates.
+```bash
+turbo run build --filter=api
+```
 
-## Deployment pitfalls
+</TabItem>
 
-Common issues to watch for when deploying Mastra in a monorepo:
+</Tabs>
 
-- **Wrong project root**: make sure the correct package (e.g. `apps/api`) is selected as the deploy target.
+Your package's `build` script should run `mastra build`:
 
-## Bundler options
+```json title="apps/api/package.json"
+{
+  "scripts": {
+    "build": "mastra build"
+  }
+}
+```
 
-Use `transpilePackages` to compile TypeScript workspace packages or libraries. List package names exactly as they appear in each `package.json`. Use `externals` to exclude dependencies resolved at runtime, and `sourcemap` to emit readable stack traces.
+## Workspace packages
 
-```typescript title="src/mastra/index.ts" showLineNumbers copy
-import { Mastra } from "@mastra/core";
+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`](/reference/v1/configuration#bundlertranspilepackages):
+
+```typescript title="src/mastra/index.ts"
 export const mastra = new Mastra({
-  // ...
   bundler: {
-    transpilePackages: ["utils"],
-    externals: ["ui"],
-    sourcemap: true,
+    transpilePackages: ["@my-org/utils"],
   },
 });
 ```
 
-> See [Mastra Class](/reference/v1/core/mastra-class) for more configuration options.
+## Environment variables
 
-## Supported monorepos
+Store `.env` files in the Mastra application directory (e.g., `apps/api/.env`), not the monorepo root.
 
-Mastra works with:
+## Deployment configuration
 
-- npm workspaces
-- pnpm workspaces
-- Yarn workspaces
-- Turborepo
+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.
 
-Known limitations:
+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](/docs/v1/mastra-cloud/overview). While the interface may differ between providers, the configuration remains the same.
+
+![Deployment configuration](/img/monorepo/monorepo-mastra-cloud.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`](/reference/v1/configuration#bundlertranspilepackages) in your Mastra config
 
-- 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
+## Related
 
-> If you are experiencing issues with monorepos see our: [Monorepos Support mega issue](https://github.com/mastra-ai/mastra/issues/6852).
+- [Deploy a Mastra Server](/docs/v1/deployment/mastra-server) - Core build and deployment guide
+- [Configuration Reference](/reference/v1/configuration) - `bundler.transpilePackages` and other options
+- [CLI Reference](/reference/v1/cli/mastra) - Build command flags

package/.docs/raw/deployment/overview.mdx

@@ -1,82 +1,69 @@
 ---
 title: "Deployment Overview | Deployment"
 description: Learn about different deployment options for your Mastra applications
+packages:
+  - "@mastra/deployer"
 ---
 
 # Deployment Overview
 
-Mastra offers multiple deployment options to suit your application's needs, from fully-managed solutions to self-hosted options, and web framework integrations. This guide will help you understand the available deployment paths and choose the right one for your project.
+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.
 
-## Choosing a Deployment Option
+## Runtime support
 
-| Option                   | Best For                                                      | Key Benefits                                                         |
-| ------------------------ | ------------------------------------------------------------- | -------------------------------------------------------------------- |
-| **Mastra Cloud**         | Teams wanting to ship quickly without infrastructure concerns | Fully-managed, automatic scaling, built-in observability             |
-| **Framework Deployment** | Teams already using Next.js, Astro etc                        | Simplify deployment with a unified codebase for frontend and backend |
-| **Server Deployment**    | Teams needing maximum control and customization               | Full control, custom middleware, integrate with existing apps        |
-| **Serverless Platforms** | Teams already using Vercel, Netlify, or Cloudflare            | Platform integration, simplified deployment, automatic scaling       |
-
-## Deployment Options
-
-### Runtime support
+Mastra can run against any of these runtime environments:
 
 - Node.js `v22.13.0` or later
 - Bun
 - Deno
-- [Cloudflare](../deployment/cloud-providers/cloudflare-deployer)
+- Cloudflare
 
-### Mastra Cloud
+## Deployment Options
 
-Mastra Cloud is a deployment platform that connects to your GitHub repository, automatically deploys on code changes, and provides monitoring tools. It includes:
+### Mastra Server
 
-- GitHub repository integration
-- Deployment on git push
-- Agent testing interface
-- Comprehensive logs and traces
-- Custom domains for each project
+Mastra provides a [server](/docs/v1/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.
 
-[View Mastra Cloud documentation →](./mastra-cloud/overview)
+Use this option when you need full control over your infrastructure, long-running processes, or WebSocket connections. The [Mastra server deployment guide](/docs/v1/deployment/mastra-server) provides more details.
 
-### With a Web Framework
+### Monorepo
 
-Mastra can be integrated with a variety of web frameworks. For example, see one of the following for a detailed guide.
+Deploy a Mastra server as part of a monorepo setup, following the same approach as standalone deployment.
 
-- [With Next.js](/guides/v1/getting-started/next-js)
-- [With Astro](/guides/v1/getting-started/astro)
+Read about [monorepo deployment](/docs/v1/deployment/monorepo).
 
-When integrated with a framework, Mastra typically requires no additional configuration for deployment.
+### Cloud Providers
 
-[View Web Framework Integration →](./web-framework)
+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.
 
-### With a Server
+Use this option for auto-scaling, minimal infrastructure management, or when you're already using one of these platforms.
 
-You can deploy Mastra as a standard Node.js HTTP server, which gives you full control over your infrastructure and deployment environment.
+- [Amazon EC2](/guides/v1/deployment/amazon-ec2)
+- [AWS Lambda](/guides/v1/deployment/aws-lambda)
+- [Azure App Services](/guides/v1/deployment/azure-app-services)
+- [Cloudflare](/guides/v1/deployment/cloudflare-deployer)
+- [Digital Ocean](/guides/v1/deployment/digital-ocean)
+- [Netlify](/guides/v1/deployment/netlify-deployer)
+- [Vercel](/guides/v1/deployment/vercel-deployer)
 
-- Custom API routes and middleware
-- Configurable CORS and authentication
-- Deploy to VMs, containers, or PaaS platforms
-- Ideal for integrating with existing Node.js applications
+### Web Framework
 
-[Building Mastra →](./building-mastra)
+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.
 
-### Serverless Platforms
+Use these guides when adding Mastra to an existing Next.js or Astro application.
 
-Mastra provides platform-specific deployers for popular serverless platforms, enabling you to deploy your application with minimal configuration.
+- [With Next.js on Vercel](/docs/v1/deployment/web-framework#with-nextjs-on-vercel)
+- [With Astro on Vercel](/docs/v1/deployment/web-framework#with-astro-on-vercel)
+- [With Astro on Netlify](/docs/v1/deployment/web-framework#with-astro-on-netlify)
 
-- Deploy to Cloudflare Workers, Vercel, or Netlify
-- Platform-specific optimizations
-- Simplified deployment process
-- Automatic scaling through the platform
+### Mastra Cloud
 
-[Building Mastra →](./building-mastra)
+We're building Mastra Cloud to be the easiest place to deploy and observe your Mastra agents. It's currently in beta.
 
-## Client Configuration
+Learn more in the [Mastra Cloud docs](/docs/v1/mastra-cloud/overview).
 
-Once your Mastra application is deployed, you'll need to configure your client to communicate with it. The Mastra Client SDK provides a simple and type-safe interface for interacting with your Mastra server.
+## Workflow Runners
 
-- Type-safe API interactions
-- Authentication and request handling
-- Retries and error handling
-- Support for streaming responses
+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.
 
-[Client configuration guide →](/docs/v1/server-db/mastra-client)
+Visit the [Workflow Runners guide](/docs/v1/deployment/workflow-runners) for execution options and the [Inngest deployment guide](/guides/v1/deployment/inngest) for setup instructions.

package/.docs/raw/deployment/web-framework.mdx

@@ -1,24 +1,28 @@
 ---
-title: "Web Framework Integration | Deployment"
+title: "Deploy with a Web Framework | Deployment"
 description: "Learn how Mastra can be deployed when integrated with a Web Framework"
+packages:
+  - "@mastra/deployer"
 ---
 
-# Web Framework Integration
+# Deploy with a Web Framework
 
-This guide covers deploying integrated Mastra applications. Mastra can be integrated with a variety of web frameworks, see one of the following for a detailed guide.
+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](/reference/v1/storage/libsql) from your Mastra configuration. LibSQLStore requires filesystem access and is not compatible with serverless platforms.
+:::
+
+Integration guides:
 
 - [With Next.js](/guides/v1/getting-started/next-js)
 - [With Astro](/guides/v1/getting-started/astro)
 
-When integrated with a framework, Mastra typically requires no additional configuration for deployment.
-
 ## With Next.js on Vercel
 
-If you've integrated Mastra with Next.js [by following our guide](/guides/v1/getting-started/next-js) and plan to deploy to Vercel, no additional setup is required.
+If you've integrated Mastra with Next.js [by following our guide](/guides/v1/getting-started/next-js) and plan to deploy to Vercel, add `serverExternalPackages: ["@mastra/*"]` to your `next.config.ts`:
 
-The only thing to verify is that you've added the following to your `next.config.ts` and removed any usage of [LibSQLStore](/docs/v1/deployment/overview), which is not supported in serverless environments:
-
-```typescript {4} title="next.config.ts" showLineNumbers copy
+```typescript {4} title="next.config.ts"
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
@@ -30,16 +34,13 @@ export default nextConfig;
 
 ## With Astro on Vercel
 
-If you've integrated Mastra with Astro [by following our guide](/guides/v1/getting-started/astro) and plan to deploy to Vercel, no additional setup is required.
-
-The only thing to verify is that you've added the following to your `astro.config.mjs` and removed any usage of [LibSQLStore](/docs/v1/deployment/overview), which is not supported in serverless environments:
+If you've integrated Mastra with Astro [by following our guide](/guides/v1/getting-started/astro) and plan to deploy to Vercel, add the Vercel adapter and server output to your `astro.config.mjs`:
 
-```javascript {2,6,7} title="astro.config.mjs" showLineNumbers copy
+```javascript {2,5-6} title="astro.config.mjs"
 import { defineConfig } from "astro/config";
 import vercel from "@astrojs/vercel";
 
 export default defineConfig({
-  // ...
   adapter: vercel(),
   output: "server",
 });
@@ -47,16 +48,13 @@ export default defineConfig({
 
 ## With Astro on Netlify
 
-If you've integrated Mastra with Astro [by following our guide](/guides/v1/getting-started/astro) and plan to deploy to Netlify, no additional setup is required.
-
-The only thing to verify is that you've added the following to your `astro.config.mjs` and removed any usage of [LibSQLStore](/docs/v1/deployment/overview), which is not supported in serverless environments:
+If you've integrated Mastra with Astro [by following our guide](/guides/v1/getting-started/astro) and plan to deploy to Netlify, add the Netlify adapter and server output to your `astro.config.mjs`:
 
-```javascript {2,6,7} title="astro.config.mjs" showLineNumbers copy
+```javascript {2,5-6} title="astro.config.mjs"
 import { defineConfig } from "astro/config";
 import netlify from "@astrojs/netlify";
 
 export default defineConfig({
-  // ...
   adapter: netlify(),
   output: "server",
 });

package/.docs/raw/deployment/workflow-runners.mdx

@@ -0,0 +1,16 @@
+---
+title: "Workflow Runners | Deployment"
+description: "Deploy Mastra workflows to specialized workflow execution platforms"
+packages:
+  - "@mastra/deployer"
+---
+
+# Workflow Runners
+
+Mastra [workflows](../workflows/overview.mdx) 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](/guides/v1/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/raw/evals/built-in-scorers.mdx

@@ -1,6 +1,8 @@
 ---
 title: "Built-in Scorers | Evals"
 description: "Overview of Mastra's ready-to-use scorers for evaluating AI outputs across quality, safety, and performance dimensions."
+packages:
+  - "@mastra/evals"
 ---
 
 # Built-in Scorers

package/.docs/raw/evals/custom-scorers.mdx

@@ -1,5 +1,7 @@
 ---
 title: "Custom Scorers | Evals"
+packages:
+  - "@mastra/core"
 ---
 
 # Custom scorers
@@ -33,17 +35,19 @@ Each step can use either **functions** or **prompt objects** (LLM-based evaluati
 - Natural language understanding tasks
 - Nuanced context evaluation
 
+**What “prompt object” means:** Instead of a function, the step is an object with `description` + `createPrompt` (and `outputSchema` for `preprocess`/`analyze`). That object tells Mastra to run the judge LLM for the step and store the structured output in `results.<step>StepResult`.
+
 You can mix and match approaches within a single scorer - for example, use a function for preprocessing data and an LLM for analyzing quality.
 
 ### Initializing a Scorer
 
-Every scorer starts with the `createScorer` factory function, which requires a name and description, and optionally accepts a type specification and judge configuration.
+Every scorer starts with the `createScorer` factory function, which requires an id and description, and optionally accepts a type specification and judge configuration.
 
 ```typescript
 import { createScorer } from '@mastra/core/evals';
 
 const glutenCheckerScorer = createScorer({
-  name: 'Gluten Checker',
+  id: 'gluten-checker',
   description: 'Check if recipes contain gluten ingredients',
   judge: {                    // Optional: for prompt object steps
     model: 'openai/gpt-5.1',
@@ -59,13 +63,55 @@ const glutenCheckerScorer = createScorer({
 
 The judge configuration is only needed if you plan to use prompt objects in any step. Individual steps can override this default configuration with their own judge settings.
 
+If all steps are function-based, the judge is never called and there is no judge output. To see LLM output, define at least one step as a prompt object and read the corresponding step result (for example, `results.analyzeStepResult`).
+
+#### Minimal judge example (prompt object)
+
+This example uses a prompt object in `analyze`, so the judge runs and its structured output is available as `results.analyzeStepResult`.
+
+```typescript
+import { createScorer } from "@mastra/core/evals";
+import { z } from "zod";
+
+const quoteSourcesScorer = createScorer({
+  id: "quote-sources",
+  description: "Check if the response includes sources",
+  judge: {
+    model: "openai/gpt-4.1-nano",
+    instructions: "You are a strict evaluator.",
+  },
+})
+  .analyze({
+    description: "Detect whether sources are present",
+    outputSchema: z.object({
+      hasSources: z.boolean(),
+      sources: z.array(z.string()),
+    }),
+    createPrompt: ({ run }) => `
+Does the response contain sources? Extract them as a list.
+
+Response:
+${run.output}
+`,
+  })
+  .generateScore(({ results }) => (results.analyzeStepResult.hasSources ? 1 : 0));
+
+// Run the scorer and inspect judge output
+const result = await quoteSourcesScorer.run({
+  input: "What is the capital of France?",
+  output: "Paris is the capital of France [1]. Source: [1] Wikipedia",
+});
+
+console.log(result.score);              // 1
+console.log(result.analyzeStepResult);  // { hasSources: true, sources: ["Wikipedia"] }
+```
+
 #### Agent Type for Agent Evaluation
 
 For type safety and compatibility with both live agent scoring and trace scoring, use `type: 'agent'` when creating scorers for agent evaluation. This allows you to use the same scorer for an agent and also use it to score traces:
 
 ```typescript
 const myScorer = createScorer({
-  // ...
   type: "agent", // Automatically handles agent input/output types
 }).generateScore(({ run, results }) => {
   // run.output is automatically typed as ScorerRunOutputForAgent
@@ -241,9 +287,13 @@ A custom scorer in Mastra uses `createScorer` with four core components:
 
 Together, these components allow you to define custom evaluation logic using LLMs as judges.
 
-> See [createScorer](/reference/v1/evals/create-scorer) for the full API and configuration options.
+:::info
+
+Visit [createScorer](/reference/v1/evals/create-scorer) for the full API and configuration options.
 
-```typescript title="src/mastra/scorers/gluten-checker.ts" showLineNumbers copy
+:::
+
+```typescript title="src/mastra/scorers/gluten-checker.ts"
 import { createScorer } from "@mastra/core/evals";
 import { z } from "zod";
 
@@ -298,7 +348,7 @@ Return your response in this format:
 "This recipe is [gluten-free/contains gluten] because [explanation]"`;
 
 export const glutenCheckerScorer = createScorer({
-  name: "Gluten Checker",
+  id: "gluten-checker",
   description: "Check if the output contains any gluten",
   judge: {
     model: "openai/gpt-4.1-nano",
@@ -395,11 +445,9 @@ Provides human-readable explanations for the score using another LLM call.
 
 The reason generation step creates explanations that help users understand why a particular score was assigned, using both the boolean result and the specific gluten sources identified by the analysis step.
 
-````
-
 ## High gluten-free example
 
-```typescript title="src/example-high-gluten-free.ts" showLineNumbers copy
+```typescript title="src/example-high-gluten-free.ts"
 const result = await glutenCheckerScorer.run({
   input: [{ role: 'user', content: 'Mix rice, beans, and vegetables' }],
   output: { text: 'Mix rice, beans, and vegetables' },
@@ -408,7 +456,7 @@ const result = await glutenCheckerScorer.run({
 console.log('Score:', result.score);
 console.log('Gluten sources:', result.analyzeStepResult.glutenSources);
 console.log('Reason:', result.reason);
-````
+```
 
 ### High gluten-free output
 
@@ -425,7 +473,7 @@ console.log('Reason:', result.reason);
 
 ## Partial gluten example
 
-```typescript title="src/example-partial-gluten.ts" showLineNumbers copy
+```typescript title="src/example-partial-gluten.ts"
 const result = await glutenCheckerScorer.run({
   input: [{ role: "user", content: "Mix flour and water to make dough" }],
   output: { text: "Mix flour and water to make dough" },
@@ -451,7 +499,7 @@ console.log("Reason:", result.reason);
 
 ## Low gluten-free example
 
-```typescript title="src/example-low-gluten-free.ts" showLineNumbers copy
+```typescript title="src/example-low-gluten-free.ts"
 const result = await glutenCheckerScorer.run({
   input: [{ role: "user", content: "Add soy sauce and noodles" }],
   output: { text: "Add soy sauce and noodles" },

package/.docs/raw/evals/overview.mdx

@@ -1,6 +1,9 @@
 ---
 title: "Scorers overview | Evals"
 description: Overview of scorers in Mastra, detailing their capabilities for evaluating AI outputs and measuring performance.
+packages:
+  - "@mastra/core"
+  - "@mastra/evals"
 ---
 
 # Scorers overview
@@ -23,7 +26,7 @@ There are different kinds of scorers, each serving a specific purpose. Here are
 
 To access Mastra's scorers feature install the `@mastra/evals` package.
 
-```bash copy
+```bash
 npm install @mastra/evals@beta
 ```
 
@@ -35,7 +38,7 @@ npm install @mastra/evals@beta
 
 You can add built-in scorers to your agents to automatically evaluate their outputs. See the [full list of built-in scorers](/docs/v1/evals/built-in-scorers) for all available options.
 
-```typescript title="src/mastra/agents/evaluated-agent.ts" showLineNumbers copy
+```typescript title="src/mastra/agents/evaluated-agent.ts"
 import { Agent } from "@mastra/core/agent";
 import {
   createAnswerRelevancyScorer,
@@ -43,7 +46,6 @@ import {
 } from "@mastra/evals/scorers/prebuilt";
 
 export const evaluatedAgent = new Agent({
-  // ...
   scorers: {
     relevancy: {
       scorer: createAnswerRelevancyScorer({ model: "openai/gpt-4.1-nano" }),
@@ -61,13 +63,12 @@ export const evaluatedAgent = new Agent({
 
 You can also add scorers to individual workflow steps to evaluate outputs at specific points in your process:
 
-```typescript title="src/mastra/workflows/content-generation.ts" showLineNumbers copy
+```typescript title="src/mastra/workflows/content-generation.ts"
 import { createWorkflow, createStep } from "@mastra/core/workflows";
 import { z } from "zod";
 import { customStepScorer } from "../scorers/custom-step-scorer";
 
 const contentStep = createStep({
-  // ...
   scorers: {
     customStepScorer: {
       scorer: customStepScorer(),
@@ -115,7 +116,6 @@ To score traces, you first need to register your scorers with your Mastra instan
 
 ```typescript
 const mastra = new Mastra({
-  // ...
   scorers: {
     answerRelevancy: myAnswerRelevancyScorer,
     responseQuality: myResponseQualityScorer,

package/.docs/raw/evals/running-in-ci.mdx

@@ -1,6 +1,8 @@
 ---
 title: "Running Scorers in CI | Evals"
 description: "Learn how to run scorer experiments in your CI/CD pipeline using the runEvals function."
+packages:
+  - "@mastra/core"
 ---
 
 # Running Scorers in CI
@@ -15,7 +17,7 @@ You can use any testing framework that supports ESM modules, such as [Vitest](ht
 
 Use `runEvals` to evaluate your agent against multiple test cases. The function accepts an array of data items, each containing an `input` and optional `groundTruth` for scorer validation.
 
-```typescript copy showLineNumbers title="src/mastra/agents/weather-agent.test.ts"
+```typescript title="src/mastra/agents/weather-agent.test.ts"
 import { describe, it, expect } from 'vitest';
 import { createScorer, runEvals } from "@mastra/core/evals";
 import { weatherAgent } from "./weather-agent";
@@ -72,7 +74,7 @@ The `runEvals` function returns an object with:
 
 Create separate test cases for different evaluation scenarios:
 
-```typescript copy showLineNumbers title="src/mastra/agents/weather-agent.test.ts"
+```typescript title="src/mastra/agents/weather-agent.test.ts"
 describe('Weather Agent Tests', () => {
   const locationScorer = createScorer({ /* ... */ });