@mastra/mcp-docs-server 0.0.0-error-handler-fix-20251020202607 → 0.0.0-execa-dynamic-import-20260304221256

package/.docs/raw/reference/rag/database-config.mdx

@@ -1,334 +0,0 @@
----
-title: "Reference: DatabaseConfig | RAG | Mastra Docs"
-description: API reference for database-specific configuration types used with vector query tools in Mastra RAG systems.
----
-
-import { Callout } from "nextra/components";
-import { Tabs } from "nextra/components";
-
-# DatabaseConfig
-
-The `DatabaseConfig` type allows you to specify database-specific configurations when using vector query tools. These configurations enable you to leverage unique features and optimizations offered by different vector stores.
-
-## Type Definition
-
-```typescript
-export type DatabaseConfig = {
-  pinecone?: PineconeConfig;
-  pgvector?: PgVectorConfig;
-  chroma?: ChromaConfig;
-  [key: string]: any; // Extensible for future databases
-};
-```
-
-## Database-Specific Types
-
-### PineconeConfig
-
-Configuration options specific to Pinecone vector store.
-
-<PropertiesTable
-  content={[
-    {
-      name: "namespace",
-      type: "string",
-      description: "Pinecone namespace for organizing and isolating vectors within the same index. Useful for multi-tenancy or environment separation.",
-      isOptional: true,
-    },
-    {
-      name: "sparseVector",
-      type: "{ indices: number[]; values: number[]; }",
-      description: "Sparse vector for hybrid search combining dense and sparse embeddings. Enables better search quality for keyword-based queries.  The indices and values arrays must be the same length.",
-      isOptional: true,
-      properties: [
-        {
-          type: "object",
-          parameters: [
-            {
-              name: "indices",
-              description: "Array of indices for sparse vector components",
-              isOptional: false,
-              type: "number[]",
-            },
-            {
-              name: "values",
-              description: "Array of values corresponding to the indices",
-              isOptional: false,
-              type: "number[]",
-            },
-          ],
-        },
-      ],
-    },
-  ]}
-/>
-
-**Use Cases:**
-- Multi-tenant applications (separate namespaces per tenant)
-- Environment isolation (dev/staging/prod namespaces)
-- Hybrid search combining semantic and keyword matching
-
-### PgVectorConfig
-
-Configuration options specific to PostgreSQL with pgvector extension.
-
-<PropertiesTable
-  content={[
-    {
-      name: "minScore",
-      type: "number",
-      description: "Minimum similarity score threshold for results. Only vectors with similarity scores above this value will be returned.",
-      isOptional: true,
-    },
-    {
-      name: "ef",
-      type: "number",
-      description: "HNSW search parameter that controls the size of the dynamic candidate list during search. Higher values improve accuracy at the cost of speed. Typically set between topK and 200.",
-      isOptional: true,
-    },
-    {
-      name: "probes",
-      type: "number",
-      description: "IVFFlat probe parameter that specifies the number of index cells to visit during search. Higher values improve recall at the cost of speed.",
-      isOptional: true,
-    },
-  ]}
-/>
-
-**Performance Guidelines:**
-- **ef**: Start with 2-4x your topK value, increase for better accuracy
-- **probes**: Start with 1-10, increase for better recall
-- **minScore**: Use values between 0.5-0.9 depending on your quality requirements
-
-**Use Cases:**
-- Performance optimization for high-load scenarios
-- Quality filtering to remove irrelevant results
-- Fine-tuning search accuracy vs speed tradeoffs
-
-### ChromaConfig
-
-Configuration options specific to Chroma vector store.
-
-<PropertiesTable
-  content={[
-    {
-      name: "where",
-      type: "Record<string, any>",
-      description: "Metadata filtering conditions using MongoDB-style query syntax. Filters results based on metadata fields.",
-      isOptional: true,
-    },
-    {
-      name: "whereDocument",
-      type: "Record<string, any>",
-      description: "Document content filtering conditions. Allows filtering based on the actual document text content.",
-      isOptional: true,
-    },
-  ]}
-/>
-
-**Filter Syntax Examples:**
-```typescript
-// Simple equality
-where: { "category": "technical" }
-
-// Operators
-where: { "price": { "$gt": 100 } }
-
-// Multiple conditions
-where: { 
-  "category": "electronics",
-  "inStock": true 
-}
-
-// Document content filtering
-whereDocument: { "$contains": "API documentation" }
-```
-
-**Use Cases:**
-- Advanced metadata filtering
-- Content-based document filtering
-- Complex query combinations
-
-## Usage Examples
-
-<Tabs items={['Basic Usage', 'Runtime Override', 'Multi-Database', 'Performance Tuning']}>
-  <Tabs.Tab>
-    ### Basic Database Configuration
-
-    ```typescript
-    import { createVectorQueryTool } from '@mastra/rag';
-    
-    const vectorTool = createVectorQueryTool({
-      vectorStoreName: 'pinecone',
-      indexName: 'documents',
-      model: embedModel,
-      databaseConfig: {
-        pinecone: {
-          namespace: 'production'
-        }
-      }
-    });
-    ```
-  </Tabs.Tab>
-
-  <Tabs.Tab>
-    ### Runtime Configuration Override
-
-    ```typescript
-    import { RuntimeContext } from '@mastra/core/runtime-context';
-    
-    // Initial configuration
-    const vectorTool = createVectorQueryTool({
-      vectorStoreName: 'pinecone',
-      indexName: 'documents', 
-      model: embedModel,
-      databaseConfig: {
-        pinecone: {
-          namespace: 'development'
-        }
-      }
-    });
-    
-    // Override at runtime
-    const runtimeContext = new RuntimeContext();
-    runtimeContext.set('databaseConfig', {
-      pinecone: {
-        namespace: 'production'
-      }
-    });
-    
-    await vectorTool.execute({
-      context: { queryText: 'search query' },
-      mastra,
-      runtimeContext
-    });
-    ```
-  </Tabs.Tab>
-
-  <Tabs.Tab>
-    ### Multi-Database Configuration
-
-    ```typescript
-    const vectorTool = createVectorQueryTool({
-      vectorStoreName: 'dynamic', // Will be determined at runtime
-      indexName: 'documents',
-      model: embedModel,
-      databaseConfig: {
-        pinecone: {
-          namespace: 'default'
-        },
-        pgvector: {
-          minScore: 0.8,
-          ef: 150
-        },
-        chroma: {
-          where: { 'type': 'documentation' }
-        }
-      }
-    });
-    ```
-
-    <Callout>
-      **Multi-Database Support**: When you configure multiple databases, only the configuration matching the actual vector store being used will be applied.
-    </Callout>
-  </Tabs.Tab>
-
-  <Tabs.Tab>
-    ### Performance Tuning
-
-    ```typescript
-    // High accuracy configuration
-    const highAccuracyTool = createVectorQueryTool({
-      vectorStoreName: 'postgres',
-      indexName: 'embeddings',
-      model: embedModel,
-      databaseConfig: {
-        pgvector: {
-          ef: 400,        // High accuracy
-          probes: 20,     // High recall
-          minScore: 0.85  // High quality threshold
-        }
-      }
-    });
-    
-    // High speed configuration  
-    const highSpeedTool = createVectorQueryTool({
-      vectorStoreName: 'postgres',
-      indexName: 'embeddings',
-      model: embedModel,
-      databaseConfig: {
-        pgvector: {
-          ef: 50,         // Lower accuracy, faster
-          probes: 3,      // Lower recall, faster
-          minScore: 0.6   // Lower quality threshold
-        }
-      }
-    });
-    ```
-  </Tabs.Tab>
-</Tabs>
-
-## Extensibility
-
-The `DatabaseConfig` type is designed to be extensible. To add support for a new vector database:
-
-```typescript
-// 1. Define the configuration interface
-export interface NewDatabaseConfig {
-  customParam1?: string;
-  customParam2?: number;
-}
-
-// 2. Extend DatabaseConfig type
-export type DatabaseConfig = {
-  pinecone?: PineconeConfig;
-  pgvector?: PgVectorConfig;
-  chroma?: ChromaConfig;
-  newdatabase?: NewDatabaseConfig;
-  [key: string]: any;
-};
-
-// 3. Use in vector query tool
-const vectorTool = createVectorQueryTool({
-  vectorStoreName: 'newdatabase',
-  indexName: 'documents',
-  model: embedModel,
-  databaseConfig: {
-    newdatabase: {
-      customParam1: 'value',
-      customParam2: 42
-    }
-  }
-});
-```
-
-## Best Practices
-
-1. **Environment Configuration**: Use different namespaces or configurations for different environments
-2. **Performance Tuning**: Start with default values and adjust based on your specific needs
-3. **Quality Filtering**: Use minScore to filter out low-quality results
-4. **Runtime Flexibility**: Override configurations at runtime for dynamic scenarios
-5. **Documentation**: Document your specific configuration choices for team members
-
-## Migration Guide
-
-Existing vector query tools continue to work without changes. To add database configurations:
-
-```diff
-const vectorTool = createVectorQueryTool({
-  vectorStoreName: 'pinecone',
-  indexName: 'documents',
-  model: embedModel,
-+ databaseConfig: {
-+   pinecone: {
-+     namespace: 'production'
-+   }
-+ }
-});
-```
-
-## Related
-
-- [createVectorQueryTool()](/reference/tools/vector-query-tool)
-- [Hybrid Vector Search](/examples/rag/query/hybrid-vector-search.mdx)
-- [Metadata Filters](/reference/rag/metadata-filters) 

package/.docs/raw/reference/rag/document.mdx

@@ -1,131 +0,0 @@
----
-title: "Reference: MDocument | Document Processing | RAG | Mastra Docs"
-description: Documentation for the MDocument class in Mastra, which handles document processing and chunking.
----
-
-# MDocument
-
-The MDocument class processes documents for RAG applications. The main methods are `.chunk()` and `.extractMetadata()`.
-
-## Constructor
-
-<PropertiesTable
-  content={[
-    {
-      name: "docs",
-      type: "Array<{ text: string, metadata?: Record<string, any> }>",
-      description:
-        "Array of document chunks with their text content and optional metadata",
-    },
-    {
-      name: "type",
-      type: "'text' | 'html' | 'markdown' | 'json' | 'latex'",
-      description: "Type of document content",
-    },
-  ]}
-/>
-
-## Static Methods
-
-### fromText()
-
-Creates a document from plain text content.
-
-```typescript
-static fromText(text: string, metadata?: Record<string, any>): MDocument
-```
-
-### fromHTML()
-
-Creates a document from HTML content.
-
-```typescript
-static fromHTML(html: string, metadata?: Record<string, any>): MDocument
-```
-
-### fromMarkdown()
-
-Creates a document from Markdown content.
-
-```typescript
-static fromMarkdown(markdown: string, metadata?: Record<string, any>): MDocument
-```
-
-### fromJSON()
-
-Creates a document from JSON content.
-
-```typescript
-static fromJSON(json: string, metadata?: Record<string, any>): MDocument
-```
-
-## Instance Methods
-
-### chunk()
-
-Splits document into chunks and optionally extracts metadata.
-
-```typescript
-async chunk(params?: ChunkParams): Promise<Chunk[]>
-```
-
-See [chunk() reference](./chunk) for detailed options.
-
-### getDocs()
-
-Returns array of processed document chunks.
-
-```typescript
-getDocs(): Chunk[]
-```
-
-### getText()
-
-Returns array of text strings from chunks.
-
-```typescript
-getText(): string[]
-```
-
-### getMetadata()
-
-Returns array of metadata objects from chunks.
-
-```typescript
-getMetadata(): Record<string, any>[]
-```
-
-### extractMetadata()
-
-Extracts metadata using specified extractors. See [ExtractParams reference](./extract-params) for details.
-
-```typescript
-async extractMetadata(params: ExtractParams): Promise<MDocument>
-```
-
-## Examples
-
-```typescript
-import { MDocument } from "@mastra/rag";
-
-// Create document from text
-const doc = MDocument.fromText("Your content here");
-
-// Split into chunks with metadata extraction
-const chunks = await doc.chunk({
-  strategy: "markdown",
-  headers: [
-    ["#", "title"],
-    ["##", "section"],
-  ],
-  extract: {
-    summary: true, // Extract summaries with default settings
-    keywords: true, // Extract keywords with default settings
-  },
-});
-
-// Get processed chunks
-const docs = doc.getDocs();
-const texts = doc.getText();
-const metadata = doc.getMetadata();
-```

package/.docs/raw/reference/rag/embeddings.mdx

@@ -1,168 +0,0 @@
----
-title: "Reference: embed() | Document Embedding | RAG | Mastra Docs"
-description: Documentation for embedding functionality in Mastra using the AI SDK.
----
-
-# Embed
-
-Mastra uses the AI SDK's `embed` and `embedMany` functions to generate vector embeddings for text inputs, enabling similarity search and RAG workflows.
-
-## Single Embedding
-
-The `embed` function generates a vector embedding for a single text input:
-
-```typescript
-import { embed } from "ai";
-
-const result = await embed({
-  model: openai.embedding("text-embedding-3-small"),
-  value: "Your text to embed",
-  maxRetries: 2, // optional, defaults to 2
-});
-```
-
-### Parameters
-
-<PropertiesTable
-  content={[
-    {
-      name: "model",
-      type: "EmbeddingModel",
-      description:
-        "The embedding model to use (e.g. openai.embedding('text-embedding-3-small'))",
-    },
-    {
-      name: "value",
-      type: "string | Record<string, any>",
-      description: "The text content or object to embed",
-    },
-    {
-      name: "maxRetries",
-      type: "number",
-      description:
-        "Maximum number of retries per embedding call. Set to 0 to disable retries.",
-      isOptional: true,
-      defaultValue: "2",
-    },
-    {
-      name: "abortSignal",
-      type: "AbortSignal",
-      description: "Optional abort signal to cancel the request",
-      isOptional: true,
-    },
-    {
-      name: "headers",
-      type: "Record<string, string>",
-      description:
-        "Additional HTTP headers for the request (only for HTTP-based providers)",
-      isOptional: true,
-    },
-  ]}
-/>
-
-### Return Value
-
-<PropertiesTable
-  content={[
-    {
-      name: "embedding",
-      type: "number[]",
-      description: "The embedding vector for the input",
-    },
-  ]}
-/>
-
-## Multiple Embeddings
-
-For embedding multiple texts at once, use the `embedMany` function:
-
-```typescript
-import { embedMany } from "ai";
-
-const result = await embedMany({
-  model: openai.embedding("text-embedding-3-small"),
-  values: ["First text", "Second text", "Third text"],
-  maxRetries: 2, // optional, defaults to 2
-});
-```
-
-### Parameters
-
-<PropertiesTable
-  content={[
-    {
-      name: "model",
-      type: "EmbeddingModel",
-      description:
-        "The embedding model to use (e.g. openai.embedding('text-embedding-3-small'))",
-    },
-    {
-      name: "values",
-      type: "string[] | Record<string, any>[]",
-      description: "Array of text content or objects to embed",
-    },
-    {
-      name: "maxRetries",
-      type: "number",
-      description:
-        "Maximum number of retries per embedding call. Set to 0 to disable retries.",
-      isOptional: true,
-      defaultValue: "2",
-    },
-    {
-      name: "abortSignal",
-      type: "AbortSignal",
-      description: "Optional abort signal to cancel the request",
-      isOptional: true,
-    },
-    {
-      name: "headers",
-      type: "Record<string, string>",
-      description:
-        "Additional HTTP headers for the request (only for HTTP-based providers)",
-      isOptional: true,
-    },
-  ]}
-/>
-
-### Return Value
-
-<PropertiesTable
-  content={[
-    {
-      name: "embeddings",
-      type: "number[][]",
-      description:
-        "Array of embedding vectors corresponding to the input values",
-    },
-  ]}
-/>
-
-## Example Usage
-
-```typescript
-import { embed, embedMany } from "ai";
-import { openai } from "@ai-sdk/openai";
-
-// Single embedding
-const singleResult = await embed({
-  model: openai.embedding("text-embedding-3-small"),
-  value: "What is the meaning of life?",
-});
-
-// Multiple embeddings
-const multipleResult = await embedMany({
-  model: openai.embedding("text-embedding-3-small"),
-  values: [
-    "First question about life",
-    "Second question about universe",
-    "Third question about everything",
-  ],
-});
-```
-
-For more detailed information about embeddings in the Vercel AI SDK, see:
-
-- [AI SDK Embeddings Overview](https://sdk.vercel.ai/docs/ai-sdk-core/embeddings)
-- [embed()](https://sdk.vercel.ai/docs/reference/ai-sdk-core/embed)
-- [embedMany()](https://sdk.vercel.ai/docs/reference/ai-sdk-core/embed-many)