@mastra/mcp-docs-server 1.2.15-alpha.9 → 1.2.16-alpha.1

package/.docs/reference/observability/tracing/exporters/confident-ai.md

@@ -4,7 +4,7 @@
 
 Sends Tracing data to [Confident AI](https://www.confident-ai.com/) for evaluation and observability. Exported by `@mastra/deepeval`, which builds on the DeepEval SDK.
 
-See [Confident AI exporter](https://mastra.ai/docs/observability/integrations/exporters/confident-ai) for setup and usage.
+See [Confident AI exporter](https://mastra.ai/integrations/observability/confident-ai) for setup and usage.
 
 ## Constructor
 

package/.docs/reference/observability/tracing/exporters/console-exporter.md

@@ -122,7 +122,6 @@ const exporterWithLogger = new ConsoleExporter({
 ### Documentation
 
 - [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview): Complete guide
-- [Exporters](https://mastra.ai/docs/observability/integrations/overview): Exporter concepts
 
 ### Other Exporters
 

package/.docs/reference/observability/tracing/exporters/datadog.md

@@ -4,7 +4,7 @@
 
 Sends Tracing data to Datadog's LLM Observability product for monitoring and analytics.
 
-> **Info:** If you also use `dd-trace` APM auto-instrumentation and need it correctly parented under Mastra spans, use the [DatadogBridge](https://mastra.ai/reference/observability/tracing/bridges/datadog) instead. The exporter sends LLM Observability data after execution completes, so it doesn't participate in `dd-trace`'s live scope.
+> **Note:** If you also use `dd-trace` APM auto-instrumentation and need it correctly parented under Mastra spans, use the [DatadogBridge](https://mastra.ai/reference/observability/tracing/bridges/datadog) instead. The exporter sends LLM Observability data after execution completes, so it doesn't participate in `dd-trace`'s live scope.
 
 ## Constructor
 

package/.docs/reference/observability/tracing/exporters/default-exporter.md

@@ -167,7 +167,6 @@ const customExporter = new DefaultExporter({
 ### Documentation
 
 - [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview): Complete guide
-- [Exporters](https://mastra.ai/docs/observability/integrations/overview): Exporter concepts
 
 ### Other Exporters
 

package/.docs/reference/observability/tracing/exporters/mastra-platform-exporter.md

@@ -177,6 +177,18 @@ The exporter batches tracing spans, logs, metrics, scores, and feedback for effi
 
 Errors raised by `MastraPlatformExporter` use the `MASTRA_PLATFORM_EXPORTER_*` `id` prefix. The deprecated `CloudExporter` continues to emit `CLOUD_EXPORTER_*` `id`s.
 
+### Quota pause
+
+When an organization has exhausted its observability quota, the Mastra platform rejects publish requests with `402 Payment Required` plus the `x-mastra-observability: disabled` header. When the exporter sees a `402` (or the header) on any publish route, it:
+
+- Drops the rejected batch without retrying it
+- Pauses all five signal types (traces, logs, metrics, scores, feedback) and drops buffered and new events instead of sending them
+- Logs a warning that telemetry is paused
+- Probes the platform periodically with an empty batch, using the interval from the `x-mastra-observability-retry-after` header (seconds), or every 5 minutes if the header is absent
+- Resumes exporting automatically and logs a warning once the platform stops rejecting with `402`
+
+The probe timer doesn't keep the Node.js process alive, so short-lived and serverless processes exit normally while paused.
+
 ### Endpoint routing
 
 - Base origins derive signal endpoints automatically
@@ -250,7 +262,6 @@ The original `CloudExporter` is preserved unchanged so dashboards or alert rules
 ### Documentation
 
 - [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview): Complete guide
-- [Exporters](https://mastra.ai/docs/observability/integrations/overview): Exporter concepts
 
 ### Other Exporters
 

package/.docs/reference/observability/tracing/exporters/mastra-storage-exporter.md

@@ -181,7 +181,6 @@ The original `DefaultExporter` is preserved unchanged so dashboards or alert rul
 ### Documentation
 
 - [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview): Complete guide
-- [Exporters](https://mastra.ai/docs/observability/integrations/overview): Exporter concepts
 
 ### Other Exporters
 

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

@@ -200,6 +200,6 @@ Tags are stored as a JSON-stringified array in the `mastra.tags` span attribute
 
 ## Related
 
-- [OtelExporter Guide](https://mastra.ai/docs/observability/integrations/exporters/otel): Setup guide with provider configurations
-- [OtelBridge](https://mastra.ai/docs/observability/integrations/bridges/otel): For bidirectional OTEL context integration
+- [OtelExporter Guide](https://mastra.ai/integrations/observability/opentelemetry): Setup guide with provider configurations
+- [OtelBridge](https://mastra.ai/integrations/observability/opentelemetry): For bidirectional OTEL context integration
 - [Tracing Overview](https://mastra.ai/docs/observability/tracing/overview): General tracing concepts

package/.docs/reference/observability/tracing/processors/sensitive-data-filter.md

@@ -2,27 +2,50 @@
 
 # SensitiveDataFilter
 
-A SpanOutputProcessor that redacts sensitive information from span fields.
+`SensitiveDataFilter` is a span output processor that redacts values whose field names match a configured list. [`Observability`](https://mastra.ai/reference/observability/tracing/configuration) applies it to plain observability configurations by default.
 
-## Auto-applied by default
+## Usage example
 
-`Observability` automatically appends a `SensitiveDataFilter` to every configured instance's `spanOutputProcessors` so secrets are redacted before they reach exporters such as the Mastra cloud exporter. The filter runs last (after any user-provided processors) so that sensitive data introduced or surfaced by upstream processors is still redacted. You don't need to add it manually unless you want to customize its options.
-
-To opt out or customize the auto-applied filter, use the `sensitiveDataFilter` option on the [`Observability` registry config](https://mastra.ai/reference/observability/tracing/configuration):
+Configure the automatically applied filter with the top-level `sensitiveDataFilter` option. The filter runs after user-provided span output processors so it can redact values they add or expose.
 
 ```typescript
-import { Observability } from '@mastra/observability'
+import { Mastra } from '@mastra/core/mastra'
+import { Observability, MastraStorageExporter } from '@mastra/observability'
+
+export const mastra = new Mastra({
+  observability: new Observability({
+    configs: {
+      default: {
+        serviceName: 'my-service',
+        exporters: [new MastraStorageExporter()],
+      },
+    },
+    sensitiveDataFilter: {
+      sensitiveFields: ['password', 'authorization', 'customerSecret'],
+      redactionToken: '[HIDDEN]',
+      redactionStyle: 'full',
+    },
+  }),
+})
+```
 
+Passing `sensitiveFields` replaces the default field list. Include every default field you still want to redact.
+
+To disable automatic filtering for all plain configurations, set `sensitiveDataFilter` to `false`:
+
+```typescript
 new Observability({
-  configs: {/* ... */},
-  // disable the auto-applied filter
+  configs: {
+    debug: {
+      serviceName: 'debug-service',
+      exporters: [new MastraStorageExporter()],
+    },
+  },
   sensitiveDataFilter: false,
-  // or customize it
-  // sensitiveDataFilter: { sensitiveFields: ['mySecret'], redactionStyle: 'partial' },
 })
 ```
 
-If a config already includes a `SensitiveDataFilter` in `spanOutputProcessors`, the auto-applied filter is skipped to avoid double redaction. Pre-instantiated `ObservabilityInstance` values aren't modified. Add a `SensitiveDataFilter` to their processors yourself if needed.
+If a plain configuration already contains a `SensitiveDataFilter` in `spanOutputProcessors`, `Observability` uses that instance and doesn't add another. Pre-instantiated `ObservabilityInstance` values aren't modified. Add the processor when constructing those instances if they need filtering.
 
 ## Constructor
 
@@ -30,120 +53,82 @@ If a config already includes a `SensitiveDataFilter` in `spanOutputProcessors`,
 new SensitiveDataFilter(options?: SensitiveDataFilterOptions)
 ```
 
-## `SensitiveDataFilterOptions`
+**sensitiveFields** (`string[]`): Complete list of field names to redact. Matching is case-insensitive and ignores separators. Replaces the default list when provided. (Default: `['password', 'token', 'secret', 'key', 'apikey', 'auth', 'authorization', 'bearer', 'bearertoken', 'jwt', 'credential', 'clientsecret', 'privatekey', 'refresh', 'ssn']`)
+
+**redactionToken** (`string`): Replacement value used for full redaction and short values under partial redaction. (Default: `'[REDACTED]'`)
+
+**redactionStyle** (`'full' | 'partial'`): Controls whether matched values are fully or partially redacted. (Default: `'full'`)
 
 ```typescript
 interface SensitiveDataFilterOptions {
-  /**
-   * List of sensitive field names to redact.
-   * Matching is case-insensitive and normalizes separators
-   * (api-key, api_key, Api Key → apikey).
-   * Defaults include: password, token, secret, key, apikey, auth,
-   * authorization, bearer, bearertoken, jwt, credential,
-   * clientsecret, privatekey, refresh, ssn.
-   */
   sensitiveFields?: string[]
-
-  /**
-   * The token used for full redaction.
-   * Default: "[REDACTED]"
-   */
   redactionToken?: string
-
-  /**
-   * Style of redaction to use:
-   * - "full": always replace with redactionToken
-   * - "partial": show 3 characters from the start and end, redact the middle
-   * Default: "full"
-   */
   redactionStyle?: RedactionStyle
 }
-```
-
-## `RedactionStyle`
 
-```typescript
 type RedactionStyle = 'full' | 'partial'
 ```
 
-## Methods
-
-### process
-
-```typescript
-process(span: AnySpan): AnySpan
-```
+## Redaction styles
 
-Process a span by filtering sensitive data across its key fields: attributes, metadata, input, output, and errorInfo.
+### Full redaction
 
-**Returns:** A new span with sensitive values redacted.
+Full redaction replaces each matched primitive value with `redactionToken`.
 
-### shutdown
+```jsonc
+// Before
+{ "apiKey": "sk-abc123xyz789", "userId": "user_123" }
 
-```typescript
-async shutdown(): Promise<void>
+// After
+{ "apiKey": "[REDACTED]", "userId": "user_123" }
 ```
 
-No cleanup needed for this processor.
+### Partial redaction
 
-## Properties
+Partial redaction preserves the first and last three characters. Values with six or fewer characters use `redactionToken` instead. Non-string primitive values are converted to strings before redaction.
 
 ```typescript
-readonly name = 'sensitive-data-filter';
+const filter = new SensitiveDataFilter({
+  redactionStyle: 'partial',
+})
 ```
 
-## Default sensitive fields
+```jsonc
+// Before
+{ "apiKey": "sk-abc123xyz789" }
 
-When no custom fields are provided:
-
-```typescript
-[
-  'password',
-  'token',
-  'secret',
-  'key',
-  'apikey',
-  'auth',
-  'authorization',
-  'bearer',
-  'bearertoken',
-  'jwt',
-  'credential',
-  'clientsecret',
-  'privatekey',
-  'refresh',
-  'ssn',
-]
+// After
+{ "apiKey": "sk-…789" }
 ```
 
-## Processing behavior
+## Field matching
 
-### Field Matching
+Field names are lowercased and stripped of non-alphanumeric characters before comparison:
 
-- **Case-insensitive**: `APIKey`, `apikey`, `ApiKey` all match
+- `api-key`, `api_key`, `Api Key`, and `apiKey` normalize to `apikey`.
+- Matching is exact after normalization. `token` matches `Token`, but doesn't match `promptTokens`, `tokenCount`, or `authToken`.
 
-- **Separator-agnostic**: `api-key`, `api_key`, `apiKey` are treated identically
+When a matched field contains an object or array, the filter traverses that value and redacts sensitive fields within it rather than replacing the complete structure.
 
-- **Exact matching**: After normalization, fields must match exactly
-
-  - `token` matches `token`, `Token`, `TOKEN`
-  - `token` doesn't match `promptTokens` or `tokenCount`
-
-### Redaction Styles
-
-#### Full Redaction (default)
+## Processing behavior
 
-All matched values replaced with redactionToken.
+`process()` filters these top-level span fields independently:
 
-#### Partial Redaction
+- `attributes`
+- `metadata`
+- `input`
+- `output`
+- `errorInfo`
 
-- Shows first 3 and last 3 characters
-- Values ≤ 6 characters are fully redacted
-- Non-string values are converted to strings before partial redaction
+Within each field, the processor:
 
-### Error handling
+- Traverses nested objects and arrays.
+- Parses and filters JSON strings that contain objects or arrays. It then serializes the filtered value.
+- Leaves invalid JSON strings unchanged.
+- Preserves `Date` instances.
+- Replaces repeated object references with `[Circular Reference]`.
 
-If filtering a field fails, the field is replaced with:
+If filtering fails anywhere within one top-level span field, that complete field is replaced with this marker:
 
 ```typescript
 {
@@ -153,14 +138,41 @@ If filtering a field fails, the field is replaced with:
 }
 ```
 
-### Processed Fields
+## Methods
+
+### Processing
 
-The filter recursively processes:
+#### `process(span)`
 
-- `span.attributes` - Span metadata and properties
-- `span.metadata` - Custom metadata
-- `span.input` - Input data
-- `span.output` - Output data
-- `span.errorInfo` - Error information
+Redacts the supported fields on the supplied span in place and returns the same span.
+
+```typescript
+import type { AnySpan } from '@mastra/core/observability'
+import { SensitiveDataFilter } from '@mastra/observability'
+
+const filter = new SensitiveDataFilter()
+
+export function redactSpan(span: AnySpan): AnySpan {
+  return filter.process(span)
+}
+```
+
+**span** (`AnySpan`): Span whose attributes, metadata, input, output, and error information are filtered.
+
+Returns: `AnySpan`
+
+### Lifecycle
+
+#### `shutdown()`
+
+Completes processor shutdown. The current processor has no resources or state to clean up.
+
+```typescript
+await filter.shutdown()
+```
+
+Returns: `Promise<void>`
+
+## Properties
 
-Handles nested objects, arrays, and circular references safely.
+**name** (`string`): Processor identifier. (Default: `'sensitive-data-filter'`)

package/.docs/reference/observability/tracing/span-filtering.md

@@ -94,4 +94,4 @@ If `spanFilter` throws an error, Mastra keeps the span and logs the error to avo
 
 - [Tracing overview](https://mastra.ai/docs/observability/tracing/overview) for setup and concepts
 - [Configuration API](https://mastra.ai/reference/observability/tracing/configuration) for `ObservabilityInstanceConfig`
-- [Sensitive data filter](https://mastra.ai/docs/observability/integrations/processors/sensitive-data-filter) for redacting span data
+- [Sensitive data filter](https://mastra.ai/reference/observability/tracing/processors/sensitive-data-filter) for redacting span data

package/.docs/reference/processors/pii-detector.md

@@ -42,6 +42,8 @@ const processor = new PIIDetector({
 
 **options.providerOptions** (`ProviderOptions`): Provider-specific options passed to the internal detection agent. Use this to control model behavior like reasoning effort for thinking models (e.g., { openai: { reasoningEffort: 'low' } })
 
+**options.onDetection** (`(event: PIIDetectionEvent) => void | Promise<void>`): Called whenever a detection result is produced, with detectionResult, the analyzed input, whether it was flagged, and the strategyApplied (the configured strategy when flagged, otherwise none). Fires for every analyzed message in processInput and processOutputResult, and for every LLM buffer flush during streaming; the streaming regex pass only reports when PII is found. Errors thrown by the callback are logged and ignored
+
 ## Returns
 
 **id** (`string`): Processor identifier set to 'pii-detector'

package/.docs/reference/processors/prompt-injection-detector.md

@@ -38,6 +38,8 @@ const processor = new PromptInjectionDetector({
 
 **options.providerOptions** (`ProviderOptions`): Provider-specific options passed to the internal detection agent. Use this to control model behavior like reasoning effort for thinking models (e.g., { openai: { reasoningEffort: 'low' } })
 
+**options.onDetection** (`(event: PromptInjectionDetectionEvent) => void | Promise<void>`): Called for every analyzed message with detectionResult, the analyzed input, whether it was flagged, and the strategyApplied (the configured strategy when flagged, otherwise none). Use it to emit custom metrics. Errors thrown by the callback are logged and ignored
+
 ## Returns
 
 **id** (`string`): Processor identifier set to 'prompt-injection-detector'

package/.docs/reference/processors/regex-filter-processor.md

@@ -43,6 +43,24 @@ const filter = new RegexFilterProcessor({
 })
 ```
 
+Raise the streaming carryover window for long custom matches (e.g. a fixed-length secret or a value that only matches once its closing delimiter arrives):
+
+```typescript
+import { RegexFilterProcessor } from '@mastra/core/processors'
+
+const filter = new RegexFilterProcessor({
+  rules: [
+    {
+      name: 'armored-key',
+      pattern: /-----BEGIN KEY-----[A-Z]+-----END KEY-----/g,
+      replacement: '[KEY]',
+    },
+  ],
+  strategy: 'redact',
+  streamCarryoverSize: 256,
+})
+```
+
 Attach to an agent:
 
 ```typescript
@@ -80,6 +98,8 @@ const agent = new Agent({
 
 **includeRedactedValues** (`boolean`): Include the text that was redacted in each report entry. Off by default, because the values are the data the processor removes. (Default: `false`)
 
+**streamCarryoverSize** (`number`): Trailing characters the streaming redact path holds back between chunks, so a match split across a chunk boundary is redacted whole. The default covers every built-in preset with a wide margin. Raise it for custom rules whose matches stay invisible to the rule until they complete, such as a fixed-length secret or a value with a closing delimiter, when such a match can be longer than the window. (Default: `128`)
+
 ## Returns
 
 **id** (`'regex-filter'`): Processor identifier.

package/.docs/reference/processors/response-cache.md

@@ -2,6 +2,8 @@
 
 # ResponseCache
 
+> **Beta:** Breaking changes may occur without a major version bump until the API is stable.
+
 `ResponseCache` is an input processor that caches LLM responses on the request/response boundary inside the agentic loop. It hooks into `processLLMRequest` for cache lookup and short-circuits on a hit. It uses `processLLMResponse` to write the completed response.
 
 The cache key is derived from the resolved `LanguageModelV2Prompt` Mastra is about to send to the model (i.e. _after_ memory has loaded and earlier input processors have transformed the prompt) so two users with different memory contexts produce different cache keys. Each step in an agentic tool loop is independently cached.

package/.docs/reference/processors/tool-search-processor.md

@@ -29,6 +29,8 @@ const toolSearch = new ToolSearchProcessor({
 
 **options.tools** (`Record<string, Tool>`): All tools that can be searched and loaded dynamically. These tools are not immediately available to the agent — they must be discovered via search and loaded on demand.
 
+**options.includeResolvedTools** (`boolean`): Also make the tools the agent resolved for this request (MCP tools requiring the caller's credentials, or anything returned by a dynamic tools function) searchable, and withhold them from the prompt until the agent loads them. The meta-tools are never withheld. Request-resolved tools are indexed per request, so each request searches and loads its own tool instances.
+
 **options.search** (`{ topK?: number; minScore?: number; autoLoad?: boolean }`): Configuration for the search behavior.
 
 **options.search.topK** (`number`): Maximum number of tools to return in search results.
@@ -120,7 +122,37 @@ The `phase` value describes where the filter is being applied:
 - `load`: Blocks `load_tool` from loading disallowed tools.
 - `active`: Hides already-loaded tools from the current request if they're no longer allowed.
 
-If the hook throws or rejects, `ToolSearchProcessor` treats the tool as disallowed for that request. The hook may run for every matching search candidate, so keep async policy checks cheap or cached. The `search_tools` meta-tool is always available. `load_tool` is available unless `search.autoLoad` is enabled. Tools passed directly through the agent or `processInputStep` remain available unless you filter them outside `ToolSearchProcessor`.
+If the hook throws or rejects, `ToolSearchProcessor` treats the tool as disallowed for that request. The hook may run for every matching search candidate, so keep async policy checks cheap or cached. The `search_tools` meta-tool is always available. `load_tool` is available unless `search.autoLoad` is enabled. Tools passed directly through the agent or `processInputStep` remain available unless you filter them outside `ToolSearchProcessor`, or enable `includeResolvedTools`.
+
+## Searching request-resolved tools
+
+The `tools` option is fixed at construction, so you can't list tools that only exist per request (MCP tools that need the caller's credentials, or anything returned by a dynamic `tools` function). By default those tools bypass search and occupy prompt space on every turn.
+
+Set `includeResolvedTools: true` to index them for the request and withhold them from the prompt until the agent loads them:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { ToolSearchProcessor } from '@mastra/core/processors'
+
+const toolSearch = new ToolSearchProcessor({
+  tools: staticTools,
+  includeResolvedTools: true,
+})
+
+const agent = new Agent({
+  id: 'mcp-agent',
+  name: 'mcp-agent',
+  instructions: 'Search for a tool when you need a capability you do not have.',
+  model: 'openai/gpt-5.6-sol',
+  // Resolved per request, then searchable alongside staticTools
+  tools: async ({ requestContext }) => mcpClient.getTools(requestContext.get('userToken')),
+  inputProcessors: [toolSearch],
+})
+```
+
+Each request is indexed on its own, so a tool loaded by one caller never resolves to another caller's instance of the same tool name.
+
+This option applies to every tool resolved for the request, including memory, workspace, skill, and browser tools. Only the `search_tools` and `load_tool` meta-tools stay in the prompt, so any tool the agent relies on implicitly must be found through search before it can be called.
 
 ## Extended usage example
 

package/.docs/reference/pubsub/lease-provider.md

@@ -130,4 +130,4 @@ When the configured pub/sub backend doesn't implement `LeaseProvider`, the runti
 - [PubSub](https://mastra.ai/reference/pubsub/base): The event delivery contract, separate from leasing
 - [RedisStreamsPubSub](https://mastra.ai/reference/pubsub/redis-streams): The built-in backend that implements `LeaseProvider`
 - [Signals](https://mastra.ai/docs/long-running-agents/signals): The runtime that uses leasing to coordinate thread execution across processes
-- [Channels](https://mastra.ai/docs/capabilities/channels/overview): Uses leasing to coordinate agent runs in serverless and multi-instance deployments
+- [Channels](https://mastra.ai/docs/capabilities/channels): Uses leasing to coordinate agent runs in serverless and multi-instance deployments

package/.docs/{guides → reference}/rag/chunking-and-embedding.md

@@ -5,7 +5,9 @@
 Before processing, create a MDocument instance from your content. You can initialize it from different formats:
 
 ```ts
-const docFromText = MDocument.fromText('Your plain text content...')
+import { MDocument } from '@mastra/rag'
+
+const doc = MDocument.fromText('Your plain text content...')
 const docFromHTML = MDocument.fromHTML('<html>Your HTML content...</html>')
 const docFromMarkdown = MDocument.fromMarkdown('# Your Markdown content...')
 const docFromJSON = MDocument.fromJSON(`{ "key": "value" }`)
@@ -59,7 +61,7 @@ For markdown documents where preserving the semantic relationships between secti
 const chunks = await doc.chunk({
   strategy: 'semantic-markdown',
   joinThreshold: 500,
-  modelName: 'gpt-3.5-turbo',
+  modelName: 'gpt-5',
 })
 ```
 
@@ -129,51 +131,46 @@ const { embeddings } = await embedMany({
 
 ## Example: Complete pipeline
 
-Here's an example showing document processing and embedding generation with both providers:
+Here's an example showing document processing, embedding generation, and vector storage:
 
 ```ts
-import { embedMany } from 'ai'
-
+import { ModelRouterEmbeddingModel } from '@mastra/core/llm'
+import { PgVector } from '@mastra/pg'
 import { MDocument } from '@mastra/rag'
+import { embedMany } from 'ai'
 
-// Initialize document
 const doc = MDocument.fromText(`
   Climate change poses significant challenges to global agriculture.
   Rising temperatures and changing precipitation patterns affect crop yields.
 `)
 
-// Create chunks
 const chunks = await doc.chunk({
   strategy: 'recursive',
   maxSize: 256,
   overlap: 50,
 })
 
-// Generate embeddings with OpenAI
-import { ModelRouterEmbeddingModel } from '@mastra/core/llm'
-
 const { embeddings } = await embedMany({
   model: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'),
   values: chunks.map(chunk => chunk.text),
 })
 
-// OR
+const vectorStore = new PgVector({
+  id: 'pg-vector',
+  connectionString: process.env.POSTGRES_CONNECTION_STRING,
+})
 
-// Generate embeddings with Cohere
-const { embeddings } = await embedMany({
-  model: 'cohere/embed-english-v3.0',
-  values: chunks.map(chunk => chunk.text),
+await vectorStore.createIndex({
+  indexName: 'embeddings',
+  dimension: 1536,
 })
 
-// Store embeddings in your vector database
 await vectorStore.upsert({
   indexName: 'embeddings',
   vectors: embeddings,
 })
 ```
 
-##
-
 For more examples of different chunking strategies and embedding configurations, see:
 
 - [Chunk Reference](https://mastra.ai/reference/rag/chunk)
@@ -181,5 +178,5 @@ For more examples of different chunking strategies and embedding configurations,
 
 For more details on vector databases and embeddings, see:
 
-- [Vector Databases](https://mastra.ai/guides/rag/vector-databases)
+- [Vector Databases](https://mastra.ai/reference/rag/vector-databases)
 - [Embedding API Reference](https://mastra.ai/reference/rag/embeddings)

package/.docs/reference/rag/database-config.md

@@ -275,5 +275,5 @@ const vectorTool = createVectorQueryTool({
 ## Related
 
 - [createVectorQueryTool()](https://mastra.ai/reference/tools/vector-query-tool)
-- [Hybrid Vector Search](https://mastra.ai/guides/rag/retrieval)
+- [Hybrid Vector Search](https://mastra.ai/reference/rag/retrieval)
 - [Metadata Filters](https://mastra.ai/reference/rag/metadata-filters)

package/.docs/{guides/rag/graph-rag.md → reference/rag/graph-rag-guide.md}

@@ -14,7 +14,7 @@ GraphRAG is particularly effective when:
 - Understanding connections between concepts is important
 - Simple vector similarity misses important contextual relationships
 
-For straightforward semantic search without relationship traversal, use [standard retrieval methods](https://mastra.ai/guides/rag/retrieval).
+For straightforward semantic search without relationship traversal, use [standard retrieval methods](https://mastra.ai/reference/rag/retrieval).
 
 ## How GraphRAG works