@mastra/mcp-docs-server 1.3.0 → 1.3.1-alpha.1

package/.docs/docs/evals/running-in-ci.md

@@ -14,11 +14,13 @@ 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.
 
+Resolve the `target` with `mastra.getAgent()` or `mastra.getWorkflow()` rather than importing it directly. A directly imported agent or workflow has no Mastra instance attached, so registry lookups inside steps or tools (such as `mastra.getAgent('weatherAgent')`) fail, scores aren't persisted, and trace-based trajectory scoring is unavailable.
+
 ```typescript
 import { describe, it, expect } from 'vitest'
-import { createScorer, runEvals } from '@mastra/core/evals'
-import { weatherAgent } from './weather-agent'
-import { locationScorer } from '../scorers/location-scorer'
+import { runEvals } from '@mastra/core/evals'
+import { mastra } from '../src/mastra'
+import { locationScorer } from '../src/mastra/scorers/location-scorer'
 
 describe('Weather Agent Tests', () => {
   it('should correctly extract locations from queries', async () => {
@@ -37,7 +39,7 @@ describe('Weather Agent Tests', () => {
           groundTruth: { expectedLocation: 'Berlin', expectedCountry: 'RU' },
         },
       ],
-      target: weatherAgent,
+      target: mastra.getAgent('weatherAgent'),
       scorers: [locationScorer],
     })
 
@@ -73,7 +75,7 @@ Create separate test cases for different evaluation scenarios:
 
 ```typescript
 describe('Weather Agent Tests', () => {
-  const locationScorer = createScorer({/* ... */})
+  const weatherAgent = mastra.getAgent('weatherAgent')
 
   it('should handle location disambiguation', async () => {
     const result = await runEvals({

package/.docs/docs/evals/vitest-integration.md

@@ -30,6 +30,29 @@ export default defineConfig({
 
 The setup file registers the custom matchers on `expect`. Alternatively, call `registerEvalMatchers()` from `@mastra/evals/vitest` in your own setup file.
 
+## Resolving targets from the Mastra instance
+
+Get the `target` (and any registered scorers) from your `Mastra` instance with `mastra.getAgent()`, `mastra.getWorkflow()`, and `mastra.getScorer()` instead of importing the agent or workflow file directly. A directly imported agent or workflow has no Mastra instance attached, so anything that reaches into the registry at runtime fails. For example, a workflow step that calls `mastra.getAgent('weatherAgent')` throws because `mastra` is `undefined`, and the same applies to child workflows, `.agent('agent-id')` references by string, and tools that call `mastra.getWorkflow()`. Registered targets also attach the configured `storage`, which is what lets scores persist and trace-based trajectory scoring work. `runEvals` logs a warning when the target isn't registered.
+
+The examples below look up `answerRelevancyScorer` and `trajectoryAccuracyScorer` with `mastra.getScorer()`, so register them on the `Mastra` instance first:
+
+```typescript
+import { Mastra } from '@mastra/core'
+import {
+  createAnswerRelevancyScorer,
+  createTrajectoryAccuracyScorerCode,
+} from '@mastra/evals/scorers/prebuilt'
+
+export const mastra = new Mastra({
+  agents: { weatherAgent },
+  workflows: { weatherWorkflow },
+  scorers: {
+    answerRelevancyScorer: createAnswerRelevancyScorer({ model: 'openai/gpt-5-mini' }),
+    trajectoryAccuracyScorer: createTrajectoryAccuracyScorerCode(),
+  },
+})
+```
+
 ## Asserting on a dataset with `expectEvals`
 
 `expectEvals` runs a `runEvals` evaluation inside a regular `test()` and asserts a minimum pass rate. It accepts the same configuration as `runEvals`: a `target` agent or workflow, `data` items, and `scorers`, `gates`, or thresholds. Gates score each item pass/fail, so `toPass(0.8)` requires at least 80% of items to pass every gate. Scorer thresholds still compare the average score across items and must pass regardless of the rate:
@@ -37,20 +60,15 @@ The setup file registers the custom matchers on `expect`. Alternatively, call `r
 ```typescript
 import { test } from 'vitest'
 import { expectEvals } from '@mastra/evals/vitest'
-import { capitalsAgent } from './capitals-agent'
-import { containsGroundTruth } from '../scorers'
-import { createKeywordCoverageScorer } from '@mastra/evals/scorers/prebuilt'
+import { checks } from '@mastra/evals/checks'
+import { mastra } from '../src/mastra'
 
-test('capitals agent answers with the expected city', { timeout: 60_000 }, async () => {
+test('weather agent calls the tool and answers relevantly', { timeout: 60_000 }, async () => {
   await expectEvals({
-    target: capitalsAgent,
-    data: [
-      { input: 'What is the capital of France?', groundTruth: 'Paris' },
-      { input: 'What is the capital of Japan?', groundTruth: 'Tokyo' },
-      { input: 'What is the capital of Australia?', groundTruth: 'Canberra' },
-    ],
-    gates: [containsGroundTruth],
-    scorers: [{ scorer: createKeywordCoverageScorer(), threshold: 0.4 }],
+    target: mastra.getAgent('weatherAgent'),
+    data: [{ input: "What's the weather in London?" }],
+    gates: [checks.calledTool('weatherTool'), checks.noToolErrors(), checks.includes('London')],
+    scorers: [{ scorer: mastra.getScorer('answerRelevancyScorer'), threshold: 0.7 }],
   }).toPass(0.8)
 })
 ```
@@ -66,18 +84,18 @@ LLM-backed evals are far slower than Vitest's default 5-second timeout, so pass
 ```typescript
 import { test } from 'vitest'
 import { expectEval } from '@mastra/evals/vitest'
-import { capitalsAgent } from './capitals-agent'
-import { containsGroundTruth } from '../scorers'
+import { checks } from '@mastra/evals/checks'
+import { mastra } from '../src/mastra'
 
 test.for([
-  { input: 'What is the capital of France?', groundTruth: 'Paris' },
-  { input: 'What is the capital of Japan?', groundTruth: 'Tokyo' },
-  { input: 'What is the capital of Australia?', groundTruth: 'Canberra' },
-])('capitals agent: $input', { timeout: 60_000 }, async item => {
+  { input: "What's the weather in London?", groundTruth: 'London' },
+  { input: "What's the weather in Tokyo?", groundTruth: 'Tokyo' },
+  { input: "What's the weather in Sydney?", groundTruth: 'Sydney' },
+])('weather agent: $input', { timeout: 60_000 }, async item => {
   await expectEval({
-    target: capitalsAgent,
+    target: mastra.getAgent('weatherAgent'),
     data: item,
-    gates: [containsGroundTruth],
+    gates: [checks.calledTool('weatherTool'), checks.includes(item.groundTruth)],
   }).toPass()
 })
 ```
@@ -91,20 +109,20 @@ For finer-grained control, call `runEvals` directly inside a regular `test()` an
 ```typescript
 import { test, expect } from 'vitest'
 import { runEvals } from '@mastra/core/evals'
-import { supportAgent } from './support-agent'
-import { relevancyScorer, noRefusalScorer } from '../scorers'
+import { checks } from '@mastra/evals/checks'
+import { mastra } from '../src/mastra'
 
-test('support agent quality', { timeout: 60_000 }, async () => {
+test('weather agent quality', { timeout: 60_000 }, async () => {
   const result = await runEvals({
-    target: supportAgent,
-    data: [{ input: 'How do I update my payment method?' }],
-    scorers: [relevancyScorer],
-    gates: [noRefusalScorer],
+    target: mastra.getAgent('weatherAgent'),
+    data: [{ input: "What's the weather in London?" }],
+    scorers: [mastra.getScorer('answerRelevancyScorer')],
+    gates: [checks.noToolErrors()],
   })
 
   expect(result).toHaveVerdict('passed')
   expect(result).toPassGates()
-  expect(result).toHaveScoreAbove('relevancy', 0.7)
+  expect(result).toHaveScoreAbove('answer-relevancy-scorer', 0.7)
 })
 ```
 
@@ -115,6 +133,49 @@ Available matchers:
 - `toPassGates()`: asserts all gates passed. Fails when no gates were configured.
 - `toPassThresholds()`: asserts all scorer thresholds passed. Fails when no thresholds were configured.
 
+## Evaluating a workflow
+
+Workflows are valid targets too. Use a `WorkflowScorerConfig` object for `scorers` to score the workflow output, individual steps, or the step execution trajectory, and reference nested scores with dot-paths in the matchers:
+
+```typescript
+import { test, expect } from 'vitest'
+import { runEvals } from '@mastra/core/evals'
+import { mastra } from '../src/mastra'
+
+test('weather workflow runs fetch-weather then plan-activities', { timeout: 60_000 }, async () => {
+  const result = await runEvals({
+    target: mastra.getWorkflow('weatherWorkflow'),
+    data: [
+      {
+        input: { city: 'London' },
+        expectedTrajectory: {
+          steps: [
+            { stepType: 'workflow_step', name: 'fetch-weather' },
+            { stepType: 'workflow_step', name: 'plan-activities' },
+          ],
+        },
+      },
+      {
+        input: { city: 'Tokyo' },
+        expectedTrajectory: {
+          steps: [
+            { stepType: 'workflow_step', name: 'fetch-weather' },
+            { stepType: 'workflow_step', name: 'plan-activities' },
+          ],
+        },
+      },
+    ],
+    scorers: {
+      trajectory: [mastra.getScorer('trajectoryAccuracyScorer')],
+    },
+  })
+
+  expect(result).toHaveScoreAbove('trajectory.code-trajectory-accuracy-scorer', 0.9)
+})
+```
+
+The `plan-activities` step in this workflow calls `mastra.getAgent('weatherAgent')` at runtime, which only works because the target was resolved with `mastra.getWorkflow()`. See the [`runEvals` reference](https://mastra.ai/reference/evals/run-evals) for the full `WorkflowScorerConfig` shape.
+
 ## Reading the reporter output
 
 `MastraEvalsReporter` prints a score table for every eval test after the run completes:
@@ -122,9 +183,11 @@ Available matchers:
 ```text
 Mastra Evals
 
-✓ capitals agent answers with the expected city (3 items)
-   contains-ground-truth (gate)                    1.0  ✓
-   keyword-coverage-scorer (threshold: min 0.4)    1.0  ✓
+✓ weather agent calls the tool and answers relevantly (1 item)
+   check-called-tool (gate)                        1.0  ✓
+   check-no-tool-errors (gate)                     1.0  ✓
+   check-includes (gate)                           1.0  ✓
+   answer-relevancy-scorer (threshold: min 0.7)    0.9  ✓
 
  Eval runs: 1 (1 passed)
 ```

package/.docs/integrations/observability/opentelemetry.md

@@ -861,6 +861,7 @@ Tags are exported as a JSON string in the `mastra.tags` span attribute for broad
 If traces aren't displaying or connecting as expected:
 
 - Verify OTEL SDK is initialized before Mastra (use the `--import` flag or import at the top of the entry point)
+- If you see `[OtelBridge] No OpenTelemetry tracer provider is registered globally`, the bridge can't find a tracer provider. Some frameworks create a provider without registering it globally. Pass that provider directly with `new OtelBridge({ tracerProvider })`. See [setup requirements](https://mastra.ai/reference/observability/tracing/bridges/otel)
 - Ensure the `OtelBridge` is added to your observability config
 - Check that your OTEL backend is running and accessible
 

package/.docs/reference/evals/run-evals.md

@@ -10,17 +10,16 @@ The `runEvals` function enables batch evaluation of agents and workflows by runn
 
 ```typescript
 import { runEvals } from '@mastra/core/evals'
-import { myAgent } from './agents/my-agent'
-import { myScorer1, myScorer2 } from './scorers'
+import { mastra } from './mastra'
 
 const result = await runEvals({
-  target: myAgent,
+  target: mastra.getAgent('myAgent'),
   data: [
     { input: 'What is machine learning?' },
     { input: 'Explain neural networks' },
     { input: 'How does AI work?' },
   ],
-  scorers: [myScorer1, myScorer2],
+  scorers: [mastra.getScorer('myScorer1'), mastra.getScorer('myScorer2')],
   targetOptions: { maxSteps: 5 },
   concurrency: 2,
   onItemComplete: ({ item, targetResult, scorerResults }) => {
@@ -33,15 +32,17 @@ console.log(`Average scores:`, result.scores)
 console.log(`Processed ${result.summary.totalItems} items`)
 ```
 
+Resolve the `target` from the `Mastra` instance with `mastra.getAgent()` or `mastra.getWorkflow()` rather than importing the agent or workflow directly. A directly imported target has no Mastra instance attached, so registry lookups made during execution (a step calling `mastra.getAgent()`, a child workflow, an `.agent('agent-id')` reference, a tool calling `mastra.getWorkflow()`) fail, scores aren't persisted, and trace-based trajectory extraction is unavailable. `runEvals` logs a warning when the target isn't registered.
+
 ### Multi-turn evaluation
 
 ```typescript
 import { runEvals } from '@mastra/core/evals'
 import { checks } from '@mastra/evals/checks'
-import { weatherAgent } from './agents/weather-agent'
+import { mastra } from './mastra'
 
 const result = await runEvals({
-  target: weatherAgent,
+  target: mastra.getAgent('weatherAgent'),
   data: [
     {
       inputs: [
@@ -60,13 +61,16 @@ const result = await runEvals({
 ```typescript
 import { runEvals } from '@mastra/core/evals'
 import { checks } from '@mastra/evals/checks'
-import { faithfulnessScorer } from './scorers'
+import { mastra } from './mastra'
 
 const result = await runEvals({
-  target: myAgent,
+  target: mastra.getAgent('weatherAgent'),
   data: [{ input: 'What is the weather in Brooklyn?' }],
   gates: [checks.calledTool('get_weather'), checks.noToolErrors()],
-  scorers: [{ scorer: faithfulnessScorer, threshold: 0.7 }, checks.includes('Brooklyn')],
+  scorers: [
+    { scorer: mastra.getScorer('faithfulnessScorer'), threshold: 0.7 },
+    checks.includes('Brooklyn'),
+  ],
 })
 
 result.verdict // 'passed' | 'scored' | 'failed'
@@ -173,7 +177,7 @@ import { runEvals } from '@mastra/core/evals'
 import { checks } from '@mastra/evals/checks'
 
 const result = await runEvals({
-  target: weatherAgent,
+  target: mastra.getAgent('weatherAgent'),
   data: [{ input: 'What is the weather in Brooklyn?' }],
   gates: [checks.calledTool('get_weather'), checks.noToolErrors()],
   scorers: [
@@ -213,7 +217,7 @@ const myScorer = createScorer({
 })
 
 const result = await runEvals({
-  target: chatAgent,
+  target: mastra.getAgent('chatAgent'),
   data: [
     {
       input: 'What is AI?',
@@ -240,7 +244,7 @@ import { createTrajectoryAccuracyScorerCode } from '@mastra/evals/scorers/code/t
 const trajectoryScorer = createTrajectoryAccuracyScorerCode()
 
 const result = await runEvals({
-  target: chatAgent,
+  target: mastra.getAgent('chatAgent'),
   data: [
     {
       input: 'What is the weather in London?',
@@ -265,7 +269,7 @@ Pass execution options like `maxSteps` or `modelSettings` to customize agent beh
 
 ```typescript
 const result = await runEvals({
-  target: chatAgent,
+  target: mastra.getAgent('chatAgent'),
   data: [{ input: 'Summarize this article' }, { input: 'Translate to French' }],
   scorers: [relevancyScorer],
   targetOptions: {
@@ -277,9 +281,11 @@ const result = await runEvals({
 
 ### Workflow Evaluation
 
+Resolve the workflow with `mastra.getWorkflow()` so steps that call `mastra.getAgent()` or run child workflows can reach the registry:
+
 ```typescript
 const workflowResult = await runEvals({
-  target: myWorkflow,
+  target: mastra.getWorkflow('myWorkflow'),
   data: [
     { input: { query: 'Process this data', priority: 'high' } },
     { input: { query: 'Another task', priority: 'low' } },
@@ -309,7 +315,7 @@ Add trajectory scoring to workflow evaluations to validate step execution order:
 
 ```typescript
 const workflowResult = await runEvals({
-  target: myWorkflow,
+  target: mastra.getWorkflow('myWorkflow'),
   data: [
     {
       input: { query: 'Process this data' },
@@ -340,7 +346,7 @@ Use `startOptions` on individual data items to customize each workflow run. Per-
 
 ```typescript
 const result = await runEvals({
-  target: myWorkflow,
+  target: mastra.getWorkflow('myWorkflow'),
   data: [
     {
       input: { query: 'hello' },
@@ -362,7 +368,7 @@ Use `inputs` to send sequential turns on a shared thread. Scorers see the accumu
 
 ```typescript
 const result = await runEvals({
-  target: chatAgent,
+  target: mastra.getAgent('chatAgent'),
   data: [
     {
       inputs: ['My favorite city is Brooklyn.', 'What is the weather in my favorite city?'],
@@ -385,7 +391,7 @@ Use `turns` to attach `gates`/`scorers` to individual turns. Each per-turn asser
 
 ```typescript
 const result = await runEvals({
-  target: chatAgent,
+  target: mastra.getAgent('chatAgent'),
   data: [
     {
       turns: [

package/.docs/reference/evals/trajectory-accuracy.md

@@ -221,7 +221,7 @@ const scorer = createTrajectoryAccuracyScorerCode({
 const scorer = createTrajectoryAccuracyScorerCode()
 
 await runEvals({
-  target: myAgent,
+  target: mastra.getAgent('myAgent'),
   scorers: { trajectory: [scorer] },
   data: [
     {
@@ -245,16 +245,20 @@ await runEvals({
 
 ### Evaluation modes
 
-The code-based scorer operates in two modes based on `strictOrder`:
+The code-based scorer operates in one of three modes based on `ordering`:
 
-#### Strict mode (`strictOrder: true`)
+#### Strict mode (`ordering: 'strict'`)
 
-Requires an exact match. The actual steps must match the expected steps in the same order with no extra or missing steps. Returns `1.0` for an exact match and `0.0` otherwise.
+Only an exact match (the same steps in the same order, with nothing extra or missing) scores `1.0`. Anything else gets partial credit for the expected steps that matched in position, with a penalty deducted for each extra step. For example, the two expected steps followed by one extra step scores `0.75`.
 
-#### Relaxed mode (`strictOrder: false`, default)
+#### Relaxed mode (`ordering: 'relaxed'`, default)
 
 Allows extra steps. Expected steps must appear in the correct relative order. The score is calculated based on how many expected steps were matched, with optional penalties for extra or repeated steps.
 
+#### Unordered mode (`ordering: 'unordered'`)
+
+Only checks that each expected step is present. Order is ignored, and extra steps are reported in the result but not penalized.
+
 ## Code-based scoring details
 
 - **Continuous scores**: Returns values between 0.0 and 1.0 in relaxed mode; binary (0 or 1) in strict mode
@@ -303,16 +307,16 @@ const scorer = createTrajectoryAccuracyScorerCode({
       { stepType: 'tool_call', name: 'fetch-tool' },
     ],
   },
-  comparisonOptions: { strictOrder: true },
+  comparisonOptions: { ordering: 'strict' },
 })
 
 const result = await runEvals({
-  target: myAgent,
+  target: mastra.getAgent('myAgent'),
   scorers: { trajectory: [scorer] },
   data: [{ input: 'Get my data' }],
 })
 
-console.log(result.scores.trajectory['trajectory-accuracy']) // 1.0
+console.log(result.scores.trajectory['code-trajectory-accuracy-scorer']) // 1.0
 ```
 
 ### Agent trajectory with relaxed ordering
@@ -327,7 +331,7 @@ const scorer = createTrajectoryAccuracyScorerCode({
       { stepType: 'tool_call', name: 'summarize-tool' },
     ],
   },
-  comparisonOptions: { strictOrder: false },
+  comparisonOptions: { ordering: 'relaxed' },
 })
 
 // Agent called search-tool → log-tool → summarize-tool
@@ -354,12 +358,12 @@ const scorer = createTrajectoryAccuracyScorerCode({
 })
 
 const result = await runEvals({
-  target: myWorkflow,
+  target: mastra.getWorkflow('myWorkflow'),
   scorers: { trajectory: [scorer] },
   data: [{ input: { data: 'test' } }],
 })
 
-console.log(result.scores.trajectory['trajectory-accuracy'])
+console.log(result.scores.trajectory['code-trajectory-accuracy-scorer'])
 ```
 
 ### Comparing step data
@@ -517,7 +521,7 @@ const scorer = createTrajectoryScorerCode({
 })
 
 const result = await runEvals({
-  target: myAgent,
+  target: mastra.getAgent('myAgent'),
   scorers: { trajectory: [scorer] },
   data: [
     {
@@ -583,7 +587,7 @@ const trajectoryScorer = createTrajectoryAccuracyScorerCode({
 })
 
 const result = await runEvals({
-  target: myAgent,
+  target: mastra.getAgent('myAgent'),
   scorers: {
     agent: [qualityScorer], // receives raw MastraDBMessage[] output
     trajectory: [trajectoryScorer], // receives pre-extracted Trajectory
@@ -592,7 +596,7 @@ const result = await runEvals({
 })
 
 // result.scores.agent['quality'] — agent-level score
-// result.scores.trajectory['trajectory-accuracy'] — trajectory score
+// result.scores.trajectory['code-trajectory-accuracy-scorer'] — trajectory score
 ```
 
 ### Workflow trajectory evaluation
@@ -612,7 +616,7 @@ const workflowTrajectoryScorer = createTrajectoryAccuracyScorerCode({
 })
 
 const result = await runEvals({
-  target: myWorkflow,
+  target: mastra.getWorkflow('myWorkflow'),
   scorers: {
     workflow: [outputScorer], // receives workflow output
     trajectory: [workflowTrajectoryScorer], // receives pre-extracted Trajectory from step results
@@ -621,7 +625,7 @@ const result = await runEvals({
 })
 
 // result.scores.workflow['output-quality'] — workflow-level score
-// result.scores.trajectory['trajectory-accuracy'] — trajectory score
+// result.scores.trajectory['code-trajectory-accuracy-scorer'] — trajectory score
 ```
 
 ## Related

package/.docs/reference/observability/tracing/bridges/otel.md

@@ -11,7 +11,7 @@ Enables bidirectional integration between Mastra tracing and OpenTelemetry infra
 ## Constructor
 
 ```typescript
-new OtelBridge()
+new OtelBridge(config?: OtelBridgeConfig)
 ```
 
 ## Methods
@@ -118,9 +118,18 @@ const mastra = new Mastra({
 })
 ```
 
-## `OpenTelemetry` setup requirements
+## Setup requirements
 
-The OtelBridge requires an active OpenTelemetry SDK to function. The bridge reads from OTEL's ambient context.
+The bridge creates spans through an OpenTelemetry tracer provider. For Mastra spans to be exported:
+
+- **A tracer provider must be available.** Register one globally before Mastra runs, for example by calling `sdk.start()` on `NodeSDK` from `@opentelemetry/sdk-node`, or by calling `trace.setGlobalTracerProvider(provider)`. If the provider isn't registered globally, pass it with `new OtelBridge({ tracerProvider })`.
+- **A context manager must be installed for Mastra spans to nest under outer spans.** `NodeSDK` installs one automatically. Without a context manager, spans are still exported, but Mastra root spans can't read the active span, so they start new traces instead of joining the outer trace.
+
+When no tracer provider is available, agents and workflows still run, but no Mastra spans are exported through OpenTelemetry. The bridge logs this warning once:
+
+```text
+[OtelBridge] No OpenTelemetry tracer provider is registered globally, so Mastra spans will not be exported through OpenTelemetry. ...
+```
 
 See the [OtelBridge Guide](https://mastra.ai/integrations/observability/opentelemetry) for complete setup instructions, including how to configure OTEL instrumentation and run your application.
 

package/.docs/reference/rag/vector-databases.md

@@ -54,6 +54,29 @@ const results = await store.hybridQuery({
 
 See the [MongoDB vector reference](https://mastra.ai/reference/vectors/mongodb) for details on `createSearchIndex()`, `textQuery()`, and `hybridQuery()`.
 
+### Automated Embedding
+
+MongoDB can generate the embeddings itself, so you don't need an embedding provider in your application. Create the index with `autoEmbed` and a Voyage AI model, write plain text, and search with a query string:
+
+```ts
+await store.createIndex({
+  indexName: 'myCollection',
+  autoEmbed: { model: 'voyage-4' },
+})
+await store.upsert({
+  indexName: 'myCollection',
+  documents: chunks.map(chunk => chunk.text),
+  metadata: chunks.map(chunk => ({ text: chunk.text })),
+})
+const results = await store.query({
+  indexName: 'myCollection',
+  queryText: 'search terms',
+  topK: 10,
+})
+```
+
+Automated Embedding is a MongoDB Preview feature and needs a deployment where it's available. See the [MongoDB vector reference](https://mastra.ai/reference/vectors/mongodb) for the supported options and requirements.
+
 **PgVector**:
 
 ```ts