@mastra/mcp-docs-server 1.1.5 → 1.1.6-alpha.0

package/.docs/reference/rag/document.md

@@ -0,0 +1,114 @@
+# MDocument
+
+The MDocument class processes documents for RAG applications. The main methods are `.chunk()` and `.extractMetadata()`.
+
+## Constructor
+
+**docs:** (`Array<{ text: string, metadata?: Record<string, any> }>`): Array of document chunks with their text content and optional metadata
+
+**type:** (`'text' | 'html' | 'markdown' | 'json' | 'latex'`): 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](https://mastra.ai/reference/rag/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](https://mastra.ai/reference/rag/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/reference/rag/embeddings.md

@@ -0,0 +1,92 @@
+# 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'
+import { ModelRouterEmbeddingModel } from '@mastra/core/llm'
+
+const result = await embed({
+  model: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'),
+  value: 'Your text to embed',
+  maxRetries: 2, // optional, defaults to 2
+})
+```
+
+### Parameters
+
+**model:** (`EmbeddingModel`): The embedding model to use (e.g. openai.embedding('text-embedding-3-small'))
+
+**value:** (`string | Record<string, any>`): The text content or object to embed
+
+**maxRetries?:** (`number`): Maximum number of retries per embedding call. Set to 0 to disable retries. (Default: `2`)
+
+**abortSignal?:** (`AbortSignal`): Optional abort signal to cancel the request
+
+**headers?:** (`Record<string, string>`): Additional HTTP headers for the request (only for HTTP-based providers)
+
+### Return Value
+
+**embedding:** (`number[]`): 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: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'),
+  values: ['First text', 'Second text', 'Third text'],
+  maxRetries: 2, // optional, defaults to 2
+})
+```
+
+### Parameters
+
+**model:** (`EmbeddingModel`): The embedding model to use (e.g. openai.embedding('text-embedding-3-small'))
+
+**values:** (`string[] | Record<string, any>[]`): Array of text content or objects to embed
+
+**maxRetries?:** (`number`): Maximum number of retries per embedding call. Set to 0 to disable retries. (Default: `2`)
+
+**abortSignal?:** (`AbortSignal`): Optional abort signal to cancel the request
+
+**headers?:** (`Record<string, string>`): Additional HTTP headers for the request (only for HTTP-based providers)
+
+### Return Value
+
+**embeddings:** (`number[][]`): Array of embedding vectors corresponding to the input values
+
+## Example Usage
+
+```typescript
+import { embed, embedMany } from 'ai'
+
+// Single embedding
+const singleResult = await embed({
+  model: new ModelRouterEmbeddingModel('openai/text-embedding-3-small'),
+  value: 'What is the meaning of life?',
+})
+
+// Multiple embeddings
+const multipleResult = await embedMany({
+  model: new ModelRouterEmbeddingModel('openai/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)

package/.docs/reference/rag/extract-params.md

@@ -0,0 +1,168 @@
+# ExtractParams
+
+ExtractParams configures metadata extraction from document chunks using LLM analysis.
+
+## Example
+
+```typescript
+import { MDocument } from '@mastra/rag'
+
+const doc = MDocument.fromText(text)
+const chunks = await doc.chunk({
+  extract: {
+    title: true, // Extract titles using default settings
+    summary: true, // Generate summaries using default settings
+    keywords: true, // Extract keywords using default settings
+  },
+})
+
+// Example output:
+// chunks[0].metadata = {
+//   documentTitle: "AI Systems Overview",
+//   sectionSummary: "Overview of artificial intelligence concepts and applications",
+//   excerptKeywords: "KEYWORDS: AI, machine learning, algorithms"
+// }
+```
+
+## Parameters
+
+The `extract` parameter accepts the following fields:
+
+**title?:** (`boolean | TitleExtractorsArgs`): Enable title extraction. Set to true for default settings, or provide custom configuration.
+
+**summary?:** (`boolean | SummaryExtractArgs`): Enable summary extraction. Set to true for default settings, or provide custom configuration.
+
+**questions?:** (`boolean | QuestionAnswerExtractArgs`): Enable question generation. Set to true for default settings, or provide custom configuration.
+
+**keywords?:** (`boolean | KeywordExtractArgs`): Enable keyword extraction. Set to true for default settings, or provide custom configuration.
+
+**schema?:** (`SchemaExtractArgs`): Enable structured metadata extraction using a Zod schema.
+
+## Extractor Arguments
+
+### TitleExtractorsArgs
+
+**llm?:** (`MastraLanguageModel`): AI SDK language model to use for title extraction
+
+**nodes?:** (`number`): Number of title nodes to extract
+
+**nodeTemplate?:** (`string`): Custom prompt template for title node extraction. Must include {context} placeholder
+
+**combineTemplate?:** (`string`): Custom prompt template for combining titles. Must include {context} placeholder
+
+### SummaryExtractArgs
+
+**llm?:** (`MastraLanguageModel`): AI SDK language model to use for summary extraction
+
+**summaries?:** (`('self' | 'prev' | 'next')[]`): List of summary types to generate. Can only include 'self' (current chunk), 'prev' (previous chunk), or 'next' (next chunk)
+
+**promptTemplate?:** (`string`): Custom prompt template for summary generation. Must include {context} placeholder
+
+### QuestionAnswerExtractArgs
+
+**llm?:** (`MastraLanguageModel`): AI SDK language model to use for question generation
+
+**questions?:** (`number`): Number of questions to generate
+
+**promptTemplate?:** (`string`): Custom prompt template for question generation. Must include both {context} and {numQuestions} placeholders
+
+**embeddingOnly?:** (`boolean`): If true, only generate embeddings without actual questions
+
+### KeywordExtractArgs
+
+**llm?:** (`MastraLanguageModel`): AI SDK language model to use for keyword extraction
+
+**keywords?:** (`number`): Number of keywords to extract
+
+**promptTemplate?:** (`string`): Custom prompt template for keyword extraction. Must include both {context} and {maxKeywords} placeholders
+
+### SchemaExtractArgs
+
+**schema:** (`ZodType`): Zod schema defining the structure of the data to extract.
+
+**llm?:** (`MastraLanguageModel`): AI SDK language model to use for extraction.
+
+**instructions?:** (`string`): Instructions for the LLM on what to extract.
+
+**metadataKey?:** (`string`): Key to nest extraction results under. If omitted, results are spread into the metadata object.
+
+## Advanced Example
+
+```typescript
+import { MDocument } from '@mastra/rag'
+
+const doc = MDocument.fromText(text)
+const chunks = await doc.chunk({
+  extract: {
+    // Title extraction with custom settings
+    title: {
+      nodes: 2, // Extract 2 title nodes
+      nodeTemplate: 'Generate a title for this: {context}',
+      combineTemplate: 'Combine these titles: {context}',
+    },
+
+    // Summary extraction with custom settings
+    summary: {
+      summaries: ['self'], // Generate summaries for current chunk
+      promptTemplate: 'Summarize this: {context}',
+    },
+
+    // Question generation with custom settings
+    questions: {
+      questions: 3, // Generate 3 questions
+      promptTemplate: 'Generate {numQuestions} questions about: {context}',
+      embeddingOnly: false,
+    },
+
+    // Keyword extraction with custom settings
+    keywords: {
+      keywords: 5, // Extract 5 keywords
+      promptTemplate: 'Extract {maxKeywords} key terms from: {context}',
+    },
+
+    // Schema extraction with Zod
+    schema: {
+      schema: z.object({
+        productName: z.string(),
+        category: z.enum(['electronics', 'clothing']),
+      }),
+      instructions: 'Extract product information.',
+      metadataKey: 'product',
+    },
+  },
+})
+
+// Example output:
+// chunks[0].metadata = {
+//   documentTitle: "AI in Modern Computing",
+//   sectionSummary: "Overview of AI concepts and their applications in computing",
+//   questionsThisExcerptCanAnswer: "1. What is machine learning?\n2. How do neural networks work?",
+//   excerptKeywords: "1. Machine learning\n2. Neural networks\n3. Training data",
+//   product: {
+//     productName: "Neural Net 2000",
+//     category: "electronics"
+//   }
+// }
+```
+
+## Document Grouping for Title Extraction
+
+When using the `TitleExtractor`, you can group multiple chunks together for title extraction by specifying a shared `docId` in the `metadata` field of each chunk. All chunks with the same `docId` will receive the same extracted title. If no `docId` is set, each chunk is treated as its own document for title extraction.
+
+**Example:**
+
+```ts
+import { MDocument } from '@mastra/rag'
+
+const doc = new MDocument({
+  docs: [
+    { text: 'chunk 1', metadata: { docId: 'docA' } },
+    { text: 'chunk 2', metadata: { docId: 'docA' } },
+    { text: 'chunk 3', metadata: { docId: 'docB' } },
+  ],
+  type: 'text',
+})
+
+await doc.extractMetadata({ title: true })
+// The first two chunks will share a title, while the third chunk will be assigned a separate title.
+```

package/.docs/reference/rag/graph-rag.md

@@ -0,0 +1,111 @@
+# GraphRAG
+
+The `GraphRAG` class implements a graph-based approach to retrieval augmented generation. It creates a knowledge graph from document chunks where nodes represent documents and edges represent semantic relationships, enabling both direct similarity matching and discovery of related content through graph traversal.
+
+## Basic Usage
+
+```typescript
+import { GraphRAG } from '@mastra/rag'
+
+const graphRag = new GraphRAG({
+  dimension: 1536,
+  threshold: 0.7,
+})
+
+// Create the graph from chunks and embeddings
+graphRag.createGraph(documentChunks, embeddings)
+
+// Query the graph with embedding
+const results = await graphRag.query({
+  query: queryEmbedding,
+  topK: 10,
+  randomWalkSteps: 100,
+  restartProb: 0.15,
+})
+```
+
+## Constructor Parameters
+
+**dimension?:** (`number`): Dimension of the embedding vectors (Default: `1536`)
+
+**threshold?:** (`number`): Similarity threshold for creating edges between nodes (0-1) (Default: `0.7`)
+
+## Methods
+
+### createGraph
+
+Creates a knowledge graph from document chunks and their embeddings.
+
+```typescript
+createGraph(chunks: GraphChunk[], embeddings: GraphEmbedding[]): void
+```
+
+#### Parameters
+
+**chunks:** (`GraphChunk[]`): Array of document chunks with text and metadata
+
+**embeddings:** (`GraphEmbedding[]`): Array of embeddings corresponding to chunks
+
+### query
+
+Performs a graph-based search combining vector similarity and graph traversal.
+
+```typescript
+query({
+  query,
+  topK = 10,
+  randomWalkSteps = 100,
+  restartProb = 0.15
+}: {
+  query: number[];
+  topK?: number;
+  randomWalkSteps?: number;
+  restartProb?: number;
+}): RankedNode[]
+```
+
+#### Parameters
+
+**query:** (`number[]`): Query embedding vector
+
+**topK?:** (`number`): Number of results to return (Default: `10`)
+
+**randomWalkSteps?:** (`number`): Number of steps in random walk (Default: `100`)
+
+**restartProb?:** (`number`): Probability of restarting walk from query node (Default: `0.15`)
+
+#### Returns
+
+Returns an array of `RankedNode` objects, where each node contains:
+
+**id:** (`string`): Unique identifier for the node
+
+**content:** (`string`): Text content of the document chunk
+
+**metadata:** (`Record<string, any>`): Additional metadata associated with the chunk
+
+**score:** (`number`): Combined relevance score from graph traversal
+
+## Advanced Example
+
+```typescript
+const graphRag = new GraphRAG({
+  dimension: 1536,
+  threshold: 0.8, // Stricter similarity threshold
+})
+
+// Create graph from chunks and embeddings
+graphRag.createGraph(documentChunks, embeddings)
+
+// Query with custom parameters
+const results = await graphRag.query({
+  query: queryEmbedding,
+  topK: 5,
+  randomWalkSteps: 200,
+  restartProb: 0.2,
+})
+```
+
+## Related
+
+- [createGraphRAGTool](https://mastra.ai/reference/tools/graph-rag-tool)

package/.docs/reference/rag/metadata-filters.md

@@ -0,0 +1,216 @@
+# Metadata Filters
+
+Mastra provides a unified metadata filtering syntax across all vector stores, based on MongoDB/Sift query syntax. Each vector store translates these filters into their native format.
+
+## Basic Example
+
+```typescript
+import { PgVector } from '@mastra/pg'
+
+const store = new PgVector({
+  id: 'pg-vector',
+  connectionString,
+})
+
+const results = await store.query({
+  indexName: 'my_index',
+  queryVector: queryVector,
+  topK: 10,
+  filter: {
+    category: 'electronics', // Simple equality
+    price: { $gt: 100 }, // Numeric comparison
+    tags: { $in: ['sale', 'new'] }, // Array membership
+  },
+})
+```
+
+## Supported Operators
+
+### Basic Comparison
+
+`$eq`Matches values equal to specified value{ age: { $eq: 25 } }Supported by: All except Couchbase`$ne`Matches values not equal{ status: { $ne: 'inactive' } }Supported by: All except Couchbase`$gt`Greater than{ price: { $gt: 100 } }Supported by: All except Couchbase`$gte`Greater than or equal{ rating: { $gte: 4.5 } }Supported by: All except Couchbase`$lt`Less than{ stock: { $lt: 20 } }Supported by: All except Couchbase`$lte`Less than or equal{ priority: { $lte: 3 } }Supported by: All except Couchbase
+
+### Array Operators
+
+`$in`Matches any value in array{ category: { $in: \["A", "B"] } }Supported by: All except Couchbase`$nin`Matches none of the values{ status: { $nin: \["deleted", "archived"] } }Supported by: All except Couchbase`$all`Matches arrays containing all elements{ tags: { $all: \["urgent", "high"] } }Supported by: Astra, Pinecone, Upstash, MongoDB`$elemMatch`Matches array elements meeting criteria{ scores: { $elemMatch: { $gt: 80 } } }Supported by: libSQL, PgVector, MongoDB
+
+### Logical Operators
+
+`$and`Logical AND{ $and: \[{ price: { $gt: 100 } }, { stock: { $gt: 0 } }] }Supported by: All except Vectorize, Couchbase`$or`Logical OR{ $or: \[{ status: "active" }, { priority: "high" }] }Supported by: All except Vectorize, Couchbase`$not`Logical NOT{ price: { $not: { $lt: 100 } } }Supported by: Astra, Qdrant, Upstash, PgVector, libSQL, MongoDB`$nor`Logical NOR{ $nor: \[{ status: "deleted" }, { archived: true }] }Supported by: Qdrant, Upstash, PgVector, libSQL, MongoDB
+
+### Element Operators
+
+`$exists`Matches documents with field{ rating: { $exists: true } }Supported by: All except Vectorize, Chroma, Couchbase
+
+### Custom Operators
+
+`$contains`Text contains substring{ description: { $contains: "sale" } }Supported by: Upstash, libSQL, PgVector`$regex`Regular expression match{ name: { $regex: "^test" } }Supported by: Qdrant, PgVector, Upstash, MongoDB`$size`Array length check{ tags: { $size: { $gt: 2 } } }Supported by: Astra, libSQL, PgVector, MongoDB`$geo`Geospatial query{ location: { $geo: { type: "radius", ... } } }Supported by: Qdrant`$datetime`Datetime range query{ created: { $datetime: { range: { gt: "2024-01-01" } } } }Supported by: Qdrant`$hasId`Vector ID existence check{ $hasId: \["id1", "id2"] }Supported by: Qdrant`$hasVector`Vector existence check{ $hasVector: true }Supported by: Qdrant
+
+## Common Rules and Restrictions
+
+1. Field names cannot:
+
+   - Contain dots (.) unless referring to nested fields
+   - Start with $ or contain null characters
+   - Be empty strings
+
+2. Values must be:
+
+   - Valid JSON types (string, number, boolean, object, array)
+   - Not undefined
+   - Properly typed for the operator (e.g., numbers for numeric comparisons)
+
+3. Logical operators:
+
+   - Must contain valid conditions
+   - Cannot be empty
+   - Must be properly nested
+   - Can only be used at top level or nested within other logical operators
+   - Cannot be used at field level or nested inside a field
+   - Cannot be used inside an operator
+   - Valid: `{ "$and": [{ "field": { "$gt": 100 } }] }`
+   - Valid: `{ "$or": [{ "$and": [{ "field": { "$gt": 100 } }] }] }`
+   - Invalid: `{ "field": { "$and": [{ "$gt": 100 }] } }`
+   - Invalid: `{ "field": { "$gt": { "$and": [{...}] } } }`
+
+4. $not operator:
+
+   - Must be an object
+   - Cannot be empty
+   - Can be used at field level or top level
+   - Valid: `{ "$not": { "field": "value" } }`
+   - Valid: `{ "field": { "$not": { "$eq": "value" } } }`
+
+5. Operator nesting:
+
+   - Logical operators must contain field conditions, not direct operators
+   - Valid: `{ "$and": [{ "field": { "$gt": 100 } }] }`
+   - Invalid: `{ "$and": [{ "$gt": 100 }] }`
+
+## Store-Specific Notes
+
+### Astra
+
+- Nested field queries are supported using dot notation
+- Array fields must be explicitly defined as arrays in the metadata
+- Metadata values are case-sensitive
+
+### ChromaDB
+
+- Where filters only return results where the filtered field exists in metadata
+- Empty metadata fields are not included in filter results
+- Metadata fields must be present for negative matches (e.g., $ne won't match documents missing the field)
+
+### Cloudflare Vectorize
+
+- Requires explicit metadata indexing before filtering can be used
+- Use `createMetadataIndex()` to index fields you want to filter on
+- Up to 10 metadata indexes per Vectorize index
+- String values are indexed up to first 64 bytes (truncated on UTF-8 boundaries)
+- Number values use float64 precision
+- Filter JSON must be under 2048 bytes
+- Field names cannot contain dots (.) or start with $
+- Field names limited to 512 characters
+- Vectors must be re-upserted after creating new metadata indexes to be included in filtered results
+- Range queries may have reduced accuracy with very large datasets (\~10M+ vectors)
+
+### libSQL
+
+- Supports nested object queries with dot notation
+- Array fields are validated to ensure they contain valid JSON arrays
+- Numeric comparisons maintain proper type handling
+- Empty arrays in conditions are handled gracefully
+- Metadata is stored in a JSONB column for efficient querying
+
+### PgVector
+
+- Full support for PostgreSQL's native JSON querying capabilities
+- Efficient handling of array operations using native array functions
+- Proper type handling for numbers, strings, and booleans
+- Nested field queries use PostgreSQL's JSON path syntax internally
+- Metadata is stored in a JSONB column for efficient indexing
+
+### Pinecone
+
+- Metadata field names are limited to 512 characters
+- Numeric values must be within the range of ±1e38
+- Arrays in metadata are limited to 64KB total size
+- Nested objects are flattened with dot notation
+- Metadata updates replace the entire metadata object
+
+### Qdrant
+
+- Supports advanced filtering with nested conditions
+- Payload (metadata) fields must be explicitly indexed for filtering
+- Use `createPayloadIndex()` to index fields you want to filter on:
+
+```typescript
+// Index a field before filtering on it
+await store.createPayloadIndex({
+  indexName: 'my_index',
+  fieldName: 'source',
+  fieldSchema: 'keyword', // 'keyword' | 'integer' | 'float' | 'geo' | 'text' | 'bool' | 'datetime' | 'uuid'
+})
+
+// Now filtering works
+const results = await store.query({
+  indexName: 'my_index',
+  queryVector: queryVector,
+  filter: { source: 'document-a' },
+})
+```
+
+- Efficient handling of geo-spatial queries
+- Special handling for null and empty values
+- Vector-specific filtering capabilities
+- Datetime values must be in RFC 3339 format
+
+### Upstash
+
+- 512-character limit for metadata field keys
+- Query size is limited (avoid large IN clauses)
+- No support for null/undefined values in filters
+- Translates to SQL-like syntax internally
+- Case-sensitive string comparisons
+- Metadata updates are atomic
+
+### MongoDB
+
+- Full support for MongoDB/Sift query syntax for metadata filters
+- Supports all standard comparison, array, logical, and element operators
+- Supports nested fields and arrays in metadata
+- Filtering can be applied to both `metadata` and the original document content using the `filter` and `documentFilter` options, respectively
+- `filter` applies to the metadata object; `documentFilter` applies to the original document fields
+- No artificial limits on filter size or complexity (subject to MongoDB query limits)
+- Indexing metadata fields is recommended for optimal performance
+
+### Couchbase
+
+- Currently does not have support for metadata filters. Filtering must be done client-side after retrieving results or by using the Couchbase SDK's Search capabilities directly for more complex queries.
+
+### Amazon S3 Vectors
+
+- Equality values must be primitives (string/number/boolean). `null`/`undefined`, arrays, objects, and Date are not allowed for equality. Range operators accept numbers or Date (Dates are normalized to epoch ms).
+- `$in`/`$nin` require **non-empty arrays of primitives**; Date elements are allowed and normalized to epoch ms. **Array equality** is not supported.
+- Implicit AND is canonicalized (`{a:1,b:2}` → `{$and:[{a:1},{b:2}]}`). Logical operators must contain field conditions, use non-empty arrays, and appear only at the root or within other logical operators (not inside field values).
+- Keys listed in `nonFilterableMetadataKeys` at index creation are stored but not filterable; this setting is immutable.
+- $exists requires a boolean value.
+- undefined/null/empty filters are treated as no filter.
+- Each metadata key name limited to 63 characters.
+- Total metadata per vector: Up to 40 KB (filterable + non-filterable)
+- Total metadata keys per vector: Up to 10
+- Filterable metadata per vector: Up to 2 KB
+- Non-filterable metadata keys per vector index: Up to 10
+
+## Related
+
+- [Astra](https://mastra.ai/reference/vectors/astra)
+- [Chroma](https://mastra.ai/reference/vectors/chroma)
+- [Cloudflare Vectorize](https://mastra.ai/reference/vectors/vectorize)
+- [libSQL](https://mastra.ai/reference/vectors/libsql)
+- [MongoDB](https://mastra.ai/reference/vectors/mongodb)
+- [PgStore](https://mastra.ai/reference/vectors/pg)
+- [Pinecone](https://mastra.ai/reference/vectors/pinecone)
+- [Qdrant](https://mastra.ai/reference/vectors/qdrant)
+- [Upstash](https://mastra.ai/reference/vectors/upstash)
+- [Amazon S3 Vectors](https://mastra.ai/reference/vectors/s3vectors)