@mastra/mcp-docs-server 1.0.0-beta.11 → 1.0.0-beta.14

package/.docs/raw/rag/graph-rag.mdx

@@ -0,0 +1,220 @@
+---
+title: "GraphRAG | RAG"
+description: Guide on graph-based retrieval in Mastra's RAG systems for documents with complex relationships.
+---
+
+# GraphRAG
+
+Graph-based retrieval enhances traditional vector search by following relationships between chunks of information. This approach is useful when information is spread across multiple documents or when documents reference each other.
+
+## When to use GraphRAG
+
+GraphRAG is particularly effective when:
+
+- Information is spread across multiple documents
+- Documents reference each other
+- You need to traverse relationships to find complete answers
+- Understanding connections between concepts is important
+- Simple vector similarity misses important contextual relationships
+
+For straightforward semantic search without relationship traversal, use [standard retrieval methods](/docs/v1/rag/retrieval).
+
+## How GraphRAG works
+
+GraphRAG combines vector similarity with knowledge graph traversal:
+
+1. Initial vector search retrieves relevant chunks based on semantic similarity
+2. A knowledge graph is constructed from the retrieved chunks
+3. The graph is traversed to find connected information
+4. Results include both directly relevant chunks and related content
+
+This process helps surface information that might not be semantically similar to the query but is contextually relevant through connections.
+
+## Creating a graph query tool
+
+The Graph Query Tool provides agents with the ability to perform graph-based retrieval:
+
+```ts
+import { createGraphRAGTool } from "@mastra/rag";
+import { ModelRouterEmbeddingModel } from "@mastra/core/llm";
+
+const graphQueryTool = createGraphRAGTool({
+  vectorStoreName: "pgVector",
+  indexName: "embeddings",
+  model: new ModelRouterEmbeddingModel("openai/text-embedding-3-small"),
+  graphOptions: {
+    threshold: 0.7,
+  },
+});
+```
+
+### Configuration options
+
+The `graphOptions` parameter controls how the knowledge graph is built and traversed:
+
+- `threshold`: Similarity threshold (0-1) for determining which chunks are related. Higher values create sparser graphs with stronger connections; lower values create denser graphs with more potential relationships.
+- `dimension`: Vector embedding dimension. Must match the embedding model's output dimension (e.g., 1536 for OpenAI's text-embedding-3-small).
+
+```ts
+const graphQueryTool = createGraphRAGTool({
+  vectorStoreName: "pgVector",
+  indexName: "embeddings",
+  model: new ModelRouterEmbeddingModel("openai/text-embedding-3-small"),
+  graphOptions: {
+    dimension: 1536,
+    threshold: 0.7,
+  },
+});
+```
+
+## Using GraphRAG with agents
+
+Integrate the graph query tool with an agent to enable graph-based retrieval:
+
+```ts
+import { Agent } from "@mastra/core/agent";
+
+const ragAgent = new Agent({
+  id: "rag-agent",
+  name: "GraphRAG Agent",
+  instructions: `You are a helpful assistant that answers questions based on the provided context.
+When answering questions, use the graph query tool to find relevant information and relationships.
+Base your answers on the context provided by the tool, and clearly state if the context doesn't contain enough information.`,
+  model: "openai/gpt-5.1",
+  tools: {
+    graphQueryTool,
+  },
+});
+```
+
+## Document processing and storage
+
+Before using graph-based retrieval, process documents into chunks and store their embeddings:
+
+```ts
+import { MDocument } from "@mastra/rag";
+import { embedMany } from "ai";
+import { ModelRouterEmbeddingModel } from "@mastra/core/llm";
+
+// Create and chunk document
+const doc = MDocument.fromText("Your document content here...");
+
+const chunks = await doc.chunk({
+  strategy: "recursive",
+  size: 512,
+  overlap: 50,
+  separator: "\n",
+});
+
+// Generate embeddings
+const { embeddings } = await embedMany({
+  model: new ModelRouterEmbeddingModel("openai/text-embedding-3-small"),
+  values: chunks.map((chunk) => chunk.text),
+});
+
+// Store in vector database
+const vectorStore = mastra.getVector("pgVector");
+await vectorStore.createIndex({
+  indexName: "embeddings",
+  dimension: 1536,
+});
+await vectorStore.upsert({
+  indexName: "embeddings",
+  vectors: embeddings,
+  metadata: chunks?.map((chunk) => ({ text: chunk.text })),
+});
+```
+
+## Querying with GraphRAG
+
+Once configured, the agent can perform graph-based queries:
+
+```ts
+const query = "What are the effects of infrastructure changes on local businesses?";
+const response = await ragAgent.generate(query);
+console.log(response.text);
+```
+
+The agent uses the graph query tool to:
+
+1. Convert the query to an embedding
+2. Find semantically similar chunks in the vector store
+3. Build a knowledge graph from related chunks
+4. Traverse the graph to find connected information
+5. Return comprehensive context for generating the response
+
+## Choosing the right threshold
+
+The threshold parameter significantly impacts retrieval quality:
+
+- **High threshold (0.8-0.9)**: Strict connections, fewer relationships, more precise but potentially incomplete results
+- **Medium threshold (0.6-0.8)**: Balanced approach, good for most use cases
+- **Low threshold (0.4-0.6)**: More connections, broader context, risk of including less relevant information
+
+Start with 0.7 and adjust based on your specific use case:
+
+```ts
+// Strict connections for precise answers
+const strictGraphTool = createGraphRAGTool({
+  vectorStoreName: "pgVector",
+  indexName: "embeddings",
+  model: new ModelRouterEmbeddingModel("openai/text-embedding-3-small"),
+  graphOptions: {
+    threshold: 0.85,
+  },
+});
+
+// Broader connections for exploratory queries
+const broadGraphTool = createGraphRAGTool({
+  vectorStoreName: "pgVector",
+  indexName: "embeddings",
+  model: new ModelRouterEmbeddingModel("openai/text-embedding-3-small"),
+  graphOptions: {
+    threshold: 0.5,
+  },
+});
+```
+
+## Combining with other retrieval methods
+
+GraphRAG can be used alongside other retrieval approaches:
+
+```ts
+import { createVectorQueryTool } from "@mastra/rag";
+
+const vectorQueryTool = createVectorQueryTool({
+  vectorStoreName: "pgVector",
+  indexName: "embeddings",
+  model: new ModelRouterEmbeddingModel("openai/text-embedding-3-small"),
+});
+
+const graphQueryTool = createGraphRAGTool({
+  vectorStoreName: "pgVector",
+  indexName: "embeddings",
+  model: new ModelRouterEmbeddingModel("openai/text-embedding-3-small"),
+  graphOptions: {
+    threshold: 0.7,
+  },
+});
+
+const agent = new Agent({
+  id: "rag-agent",
+  name: "RAG Agent",
+  instructions: `Use vector search for simple fact-finding queries.
+Use graph search when you need to understand relationships or find connected information.`,
+  model: "openai/gpt-5.1",
+  tools: {
+    vectorQueryTool,
+    graphQueryTool,
+  },
+});
+```
+
+This gives the agent flexibility to choose the appropriate retrieval method based on the query.
+
+## Reference
+
+For detailed API documentation, see:
+
+- [GraphRAG Class](/reference/v1/rag/graph-rag)
+- [createGraphRAGTool()](/reference/v1/tools/graph-rag-tool)

package/.docs/raw/rag/overview.mdx

@@ -18,7 +18,7 @@ Mastra's RAG system provides:
 
 To implement RAG, you process your documents into chunks, create embeddings, store them in a vector database, and then retrieve relevant context at query time.
 
-```ts showLineNumbers copy
+```ts
 import { embedMany } from "ai";
 import { PgVector } from "@mastra/pg";
 import { MDocument } from "@mastra/rag";
@@ -74,5 +74,4 @@ Mastra supports multiple vector stores for embedding persistence and similarity
 
 ## More resources
 
-- [Chain of Thought RAG Example](/examples/v1/rag/usage/cot-rag)
-- [All RAG Examples](/examples/v1/) (including different chunking strategies, embedding models, and vector stores)
+- [Chain of Thought RAG Example](https://github.com/mastra-ai/mastra/tree/main/examples/basics/rag/cot-rag)

package/.docs/raw/rag/retrieval.mdx

@@ -26,7 +26,7 @@ Mastra provides flexible retrieval options with support for semantic search, fil
 
 The simplest approach is direct semantic search. This method uses vector similarity to find chunks that are semantically similar to the query:
 
-```ts showLineNumbers copy
+```ts
 import { embed } from "ai";
 import { PgVector } from "@mastra/pg";
 import { ModelRouterEmbeddingModel } from "@mastra/core/llm";
@@ -56,7 +56,7 @@ The `topK` parameter specifies the maximum number of most similar results to ret
 
 Results include both the text content and a similarity score:
 
-```ts showLineNumbers copy
+```ts
 [
   {
     text: "Climate change poses significant challenges...",
@@ -68,7 +68,6 @@ Results include both the text content and a similarity score:
     score: 0.82,
     metadata: { source: "article1.txt" },
   },
-  // ... more results
 ];
 ```
 
@@ -76,13 +75,15 @@ Results include both the text content and a similarity score:
 
 ### Metadata Filtering
 
-Filter results based on metadata fields to narrow down the search space. This is useful when you have documents from different sources, time periods, or with specific attributes. Mastra provides a unified MongoDB-style query syntax that works across all supported vector stores.
+Filter results based on metadata fields to narrow down the search space. This approach - combining vector similarity search with metadata filters - is sometimes called hybrid vector search, as it merges semantic search with structured filtering criteria.
+
+This is useful when you have documents from different sources, time periods, or with specific attributes. Mastra provides a unified MongoDB-style query syntax that works across all supported vector stores.
 
 For detailed information about available operators and syntax, see the [Metadata Filters Reference](/reference/v1/rag/metadata-filters).
 
 Basic filtering examples:
 
-```ts showLineNumbers copy
+```ts
 // Simple equality filter
 const results = await pgVector.query({
   indexName: "embeddings",
@@ -146,13 +147,14 @@ Common use cases for metadata filtering:
 - Combine multiple conditions for precise querying
 - Filter by document attributes (e.g., language, author)
 
-For an example of how to use metadata filtering, see the [Hybrid Vector Search](/examples/v1/rag/query/hybrid-vector-search) example.
-
 ### Vector Query Tool
 
 Sometimes you want to give your agent the ability to query a vector database directly. The Vector Query Tool allows your agent to be in charge of retrieval decisions, combining semantic search with optional filtering and reranking based on the agent's understanding of the user's needs.
 
-```ts showLineNumbers copy
+```ts
+import { createVectorQueryTool } from "@mastra/rag";
+import { ModelRouterEmbeddingModel } from "@mastra/core/llm";
+
 const vectorQueryTool = createVectorQueryTool({
   vectorStoreName: "pgVector",
   indexName: "embeddings",
@@ -179,7 +181,10 @@ These configurations are for **query-time options** like namespaces, performance
 Connection credentials (URLs, auth tokens) are configured when you instantiate the vector store class (e.g., `new LibSQLVector({ connectionUrl: '...' })`).
 :::
 
-```ts showLineNumbers copy
+```ts
+import { createVectorQueryTool } from "@mastra/rag";
+import { ModelRouterEmbeddingModel } from "@mastra/core/llm";
+
 // Pinecone with namespace
 const pineconeQueryTool = createVectorQueryTool({
   vectorStoreName: "pinecone",
@@ -251,7 +256,7 @@ const lanceQueryTool = createVectorQueryTool({
 
 You can also override these configurations at runtime using the request context:
 
-```ts showLineNumbers copy
+```ts
 import { RequestContext } from "@mastra/core/request-context";
 
 const requestContext = new RequestContext();
@@ -278,7 +283,7 @@ When implementing filtering, these prompts are required in the agent's instructi
 <Tabs>
   <TabItem value="pgvector" label="pgVector">
 
-```ts showLineNumbers copy
+```ts
 import { PGVECTOR_PROMPT } from "@mastra/pg";
 
 export const ragAgent = new Agent({
@@ -297,7 +302,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="pinecone" label="Pinecone">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { PINECONE_PROMPT } from "@mastra/pinecone";
 
 export const ragAgent = new Agent({
@@ -316,7 +321,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="qdrant" label="Qdrant">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { QDRANT_PROMPT } from "@mastra/qdrant";
 
 export const ragAgent = new Agent({
@@ -335,7 +340,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="chroma" label="Chroma">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { CHROMA_PROMPT } from "@mastra/chroma";
 
 export const ragAgent = new Agent({
@@ -354,7 +359,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="astra" label="Astra">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { ASTRA_PROMPT } from "@mastra/astra";
 
 export const ragAgent = new Agent({
@@ -371,9 +376,9 @@ export const ragAgent = new Agent({
 
   </TabItem>
 
-  <TabItem value="libsql" label="LibSQL">
+  <TabItem value="libsql" label="libSQL">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { LIBSQL_PROMPT } from "@mastra/libsql";
 
 export const ragAgent = new Agent({
@@ -392,7 +397,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="upstash" label="Upstash">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { UPSTASH_PROMPT } from "@mastra/upstash";
 
 export const ragAgent = new Agent({
@@ -411,7 +416,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="vectorize" label="Vectorize">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { VECTORIZE_PROMPT } from "@mastra/vectorize";
 
 export const ragAgent = new Agent({
@@ -430,7 +435,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="mongodb" label="MongoDB">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { MONGODB_PROMPT } from "@mastra/mongodb";
 
 export const ragAgent = new Agent({
@@ -449,7 +454,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="opensearch" label="OpenSearch">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { OPENSEARCH_PROMPT } from "@mastra/opensearch";
 
 export const ragAgent = new Agent({
@@ -468,7 +473,7 @@ export const ragAgent = new Agent({
 
   <TabItem value="s3vectors" label="S3Vectors">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { S3VECTORS_PROMPT } from "@mastra/s3vectors";
 
 export const ragAgent = new Agent({
@@ -497,7 +502,7 @@ Initial vector similarity search can sometimes miss nuanced relevance. Re-rankin
 
 Here's how to use re-ranking:
 
-```ts showLineNumbers copy
+```ts
 import {
   rerankWithScorer as rerank,
   MastraAgentRelevanceScorer
@@ -535,16 +540,17 @@ The weights control how different factors influence the final ranking:
 - `vector`: Higher values favor the original vector similarity scores
 - `position`: Higher values help maintain the original ordering of results
 
-
-> **Note:** For semantic scoring to work properly during re-ranking, each result must include the text content in its `metadata.text` field.
+:::note
+For semantic scoring to work properly during re-ranking, each result must include the text content in its `metadata.text` field.
+:::
 
 You can also use other relevance score providers like Cohere or ZeroEntropy:
 
-```ts showLineNumbers copy
+```ts
 const relevanceProvider = new CohereRelevanceScorer("rerank-v3.5");
 ```
 
-```ts showLineNumbers copy
+```ts
 const relevanceProvider = new ZeroEntropyRelevanceScorer("zerank-1");
 ```
 
@@ -552,27 +558,4 @@ The re-ranked results combine vector similarity with semantic understanding to i
 
 For more details about re-ranking, see the [rerank()](/reference/v1/rag/rerankWithScorer) method.
 
-### Graph-based Retrieval
-
-For documents with complex relationships, graph-based retrieval can follow connections between chunks. This helps when:
-
-- Information is spread across multiple documents
-- Documents reference each other
-- You need to traverse relationships to find complete answers
-
-Example setup:
-
-```ts showLineNumbers copy
-const graphQueryTool = createGraphQueryTool({
-  vectorStoreName: "pgVector",
-  indexName: "embeddings",
-  model: new ModelRouterEmbeddingModel("openai/text-embedding-3-small"),
-  graphOptions: {
-    threshold: 0.7,
-  },
-});
-```
-
-For more details about graph-based retrieval, see the [GraphRAG](/reference/v1/rag/graph-rag) class and the [createGraphQueryTool()](/reference/v1/tools/graph-rag-tool) function.
-
-For an example of how to use the graph-based retrieval method, see the [Graph-based Retrieval](/examples/v1/rag/usage/graph-rag) example.
+For graph-based retrieval that follows connections between chunks, see the [GraphRAG](/docs/v1/rag/graph-rag) documentation.

package/.docs/raw/rag/vector-databases.mdx

@@ -15,7 +15,7 @@ After generating embeddings, you need to store them in a database that supports
 <Tabs>
   <TabItem value="mongodb" label="MongoDB">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { MongoDBVector } from "@mastra/mongodb";
 
 const store = new MongoDBVector({
@@ -41,7 +41,7 @@ For detailed setup instructions and best practices, see the [official MongoDB At
 
   <TabItem value="pg-vector" label="PgVector">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { PgVector } from "@mastra/pg";
 
 const store = new PgVector({
@@ -70,7 +70,7 @@ For detailed setup instructions and best practices, see the [official pgvector r
 
   <TabItem value="pinecone" label="Pinecone">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { PineconeVector } from "@mastra/pinecone";
 
 const store = new PineconeVector({
@@ -92,7 +92,7 @@ await store.upsert({
 
   <TabItem value="qdrant" label="Qdrant">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { QdrantVector } from "@mastra/qdrant";
 
 const store = new QdrantVector({
@@ -117,7 +117,7 @@ await store.upsert({
 
   <TabItem value="chroma" label="Chroma">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { ChromaVector } from "@mastra/chroma";
 
 // Running Chroma locally
@@ -147,7 +147,7 @@ await store.upsert({
 
   <TabItem value="astra" label="Astra">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { AstraVector } from "@mastra/astra";
 
 const store = new AstraVector({
@@ -170,9 +170,9 @@ await store.upsert({
 
   </TabItem>
 
-  <TabItem value="libsql" label="LibSQL">
+  <TabItem value="libsql" label="libSQL">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { LibSQLVector } from "@mastra/core/vector/libsql";
 
 const store = new LibSQLVector({
@@ -197,7 +197,7 @@ await store.upsert({
 
   <TabItem value="upstash" label="Upstash">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { UpstashVector } from "@mastra/upstash";
 
 // In upstash they refer to the store as an index
@@ -220,7 +220,7 @@ await store.upsert({
 
   <TabItem value="cloudflare" label="Cloudflare">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { CloudflareVector } from "@mastra/vectorize";
 
 const store = new CloudflareVector({
@@ -242,7 +242,7 @@ await store.upsert({
 
   <TabItem value="opensearch" label="OpenSearch">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { OpenSearchVector } from "@mastra/opensearch";
 
 const store = new OpenSearchVector({ url: process.env.OPENSEARCH_URL });
@@ -263,7 +263,7 @@ await store.upsert({
 
   <TabItem value="elasticsearch" label="ElasticSearch">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { ElasticSearchVector } from "@mastra/elasticsearch";
 
 const store = new ElasticSearchVector({ url: process.env.ELASTICSEARCH_URL });
@@ -283,7 +283,7 @@ await store.upsert({
   </TabItem>
   <TabItem value="couchbase" label="Couchbase">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { CouchbaseVector } from "@mastra/couchbase";
 
 const store = new CouchbaseVector({
@@ -308,7 +308,7 @@ await store.upsert({
   </TabItem>
   <TabItem value="lancedb" label="Lance">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { LanceVectorStore } from "@mastra/lance";
 
 const store = await LanceVectorStore.create("/path/to/db");
@@ -334,7 +334,7 @@ For detailed setup instructions and best practices, see the [official LanceDB do
   </TabItem>
   <TabItem value="s3vectors" label="S3 Vectors">
 
-```ts title="vector-store.ts" showLineNumbers copy
+```ts title="vector-store.ts"
 import { S3Vectors } from "@mastra/s3vectors";
 
 const store = new S3Vectors({
@@ -368,7 +368,7 @@ Once initialized, all vector stores share the same interface for creating indexe
 
 Before storing embeddings, you need to create an index with the appropriate dimension size for your embedding model:
 
-```ts title="store-embeddings.ts" showLineNumbers copy
+```ts title="store-embeddings.ts"
 // Create an index with dimension 1536 (for text-embedding-3-small)
 await store.createIndex({
   indexName: "myCollection",
@@ -380,9 +380,11 @@ The dimension size must match the output dimension of your chosen embedding mode
 
 - OpenAI text-embedding-3-small: 1536 dimensions (or custom, e.g., 256)
 - Cohere embed-multilingual-v3: 1024 dimensions
-- Google `text-embedding-004`: 768 dimensions (or custom)
+- Google text-embedding-004: 768 dimensions (or custom)
 
-> **Important**: Index dimensions cannot be changed after creation. To use a different model, delete and recreate the index with the new dimension size.
+:::important
+Index dimensions cannot be changed after creation. To use a different model, delete and recreate the index with the new dimension size.
+:::
 
 ### Naming Rules for Databases
 
@@ -443,7 +445,7 @@ Each vector database enforces specific naming conventions for indexes and collec
     - Example: `my_collection_123` is valid
     - Example: `my-collection` is not valid (contains hyphen)
   </TabItem>
-  <TabItem value="libsql" label="LibSQL">
+  <TabItem value="libsql" label="libSQL">
     Index names must:
     - Start with a letter or underscore
     - Contain only letters, numbers, and underscores
@@ -512,7 +514,7 @@ Each vector database enforces specific naming conventions for indexes and collec
 
 After creating an index, you can store embeddings along with their basic metadata:
 
-```ts title="store-embeddings.ts" showLineNumbers copy
+```ts title="store-embeddings.ts"
 // Store embeddings with their corresponding metadata
 await store.upsert({
   indexName: "myCollection", // index name
@@ -535,9 +537,11 @@ The upsert operation:
 
 Vector stores support rich metadata (any JSON-serializable fields) for filtering and organization. Since metadata is stored with no fixed schema, use consistent field naming to avoid unexpected query results.
 
-**Important**: Metadata is crucial for vector storage - without it, you'd only have numerical embeddings with no way to return the original text or filter results. Always store at least the source text as metadata.
+:::important
+Metadata is crucial for vector storage - without it, you'd only have numerical embeddings with no way to return the original text or filter results. Always store at least the source text as metadata.
+:::
 
-```ts showLineNumbers copy
+```ts
 // Store embeddings with rich metadata for better organization and filtering
 await store.upsert({
   indexName: "myCollection",
@@ -577,7 +581,7 @@ When building RAG applications, you often need to clean up stale vectors when do
 
 The most common use case is deleting all vectors for a specific document when a user deletes it:
 
-```ts title="delete-vectors.ts" showLineNumbers copy
+```ts title="delete-vectors.ts"
 // Delete all vectors for a specific document
 await store.deleteVectors({
   indexName: "myCollection",
@@ -594,7 +598,7 @@ This is particularly useful when:
 
 You can also use complex filters to delete vectors matching multiple conditions:
 
-```ts title="delete-vectors-advanced.ts" showLineNumbers copy
+```ts title="delete-vectors-advanced.ts"
 // Delete all vectors for multiple documents
 await store.deleteVectors({
   indexName: "myCollection",
@@ -619,7 +623,7 @@ await store.deleteVectors({
 
 If you have specific vector IDs to delete, you can pass them directly:
 
-```ts title="delete-by-ids.ts" showLineNumbers copy
+```ts title="delete-by-ids.ts"
 // Delete specific vectors by their IDs
 await store.deleteVectors({
   indexName: "myCollection",