@mastra/mcp-docs-server 0.0.0-commonjs-20250414101718

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

@@ -0,0 +1,281 @@
+---
+title: "Reference: Pinecone Vector Store | Vector DBs | RAG | Mastra Docs"
+description: Documentation for the PineconeVector class in Mastra, which provides an interface to Pinecone's vector database.
+---
+
+# Pinecone Vector Store
+
+The PineconeVector class provides an interface to [Pinecone](https://www.pinecone.io/)'s vector database.
+It provides real-time vector search, with features like hybrid search, metadata filtering, and namespace management.
+
+## Constructor Options
+
+<PropertiesTable
+  content={[
+    {
+      name: "apiKey",
+      type: "string",
+      description: "Pinecone API key",
+    },
+    {
+      name: "environment",
+      type: "string",
+      description: 'Pinecone environment (e.g., "us-west1-gcp")',
+    },
+  ]}
+/>
+
+## Methods
+
+### createIndex()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to create",
+    },
+    {
+      name: "dimension",
+      type: "number",
+      description: "Vector dimension (must match your embedding model)",
+    },
+    {
+      name: "metric",
+      type: "'cosine' | 'euclidean' | 'dotproduct'",
+      isOptional: true,
+      defaultValue: "cosine",
+      description: "Distance metric for similarity search. Use 'dotproduct' if you plan to use hybrid search.",
+    },
+  ]}
+/>
+
+### upsert()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of your Pinecone index",
+    },
+    {
+      name: "vectors",
+      type: "number[][]",
+      description: "Array of dense embedding vectors",
+    },
+    {
+      name: "sparseVectors",
+      type: "{ indices: number[], values: number[] }[]",
+      isOptional: true,
+      description: "Array of sparse vectors for hybrid search. Each vector must have matching indices and values arrays.",
+    },
+    {
+      name: "metadata",
+      type: "Record<string, any>[]",
+      isOptional: true,
+      description: "Metadata for each vector",
+    },
+    {
+      name: "ids",
+      type: "string[]",
+      isOptional: true,
+      description: "Optional vector IDs (auto-generated if not provided)",
+    },
+    {
+      name: "namespace",
+      type: "string",
+      isOptional: true,
+      description: "Optional namespace to store vectors in. Vectors in different namespaces are isolated from each other.",
+    },
+  ]}
+/>
+
+### query()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to query",
+    },
+    {
+      name: "vector",
+      type: "number[]",
+      description: "Dense query vector to find similar vectors",
+    },
+    {
+      name: "sparseVector",
+      type: "{ indices: number[], values: number[] }",
+      isOptional: true,
+      description: "Optional sparse vector for hybrid search. Must have matching indices and values arrays.",
+    },
+    {
+      name: "topK",
+      type: "number",
+      isOptional: true,
+      defaultValue: "10",
+      description: "Number of results to return",
+    },
+    {
+      name: "filter",
+      type: "Record<string, any>",
+      isOptional: true,
+      description: "Metadata filters for the query",
+    },
+    {
+      name: "includeVector",
+      type: "boolean",
+      isOptional: true,
+      defaultValue: "false",
+      description: "Whether to include the vector in the result",
+    },
+    {
+      name: "namespace",
+      type: "string",
+      isOptional: true,
+      description: "Optional namespace to query vectors from. Only returns results from the specified namespace.",
+    },
+  ]}
+/>
+
+### listIndexes()
+
+Returns an array of index names as strings.
+
+### describeIndex()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to describe",
+    },
+  ]}
+/>
+
+Returns:
+
+```typescript copy
+interface IndexStats {
+  dimension: number;
+  count: number;
+  metric: "cosine" | "euclidean" | "dotproduct";
+}
+```
+
+### deleteIndex()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to delete",
+    },
+  ]}
+/>
+
+### updateIndexById()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index containing the vector",
+    },
+    {
+      name: "id",
+      type: "string",
+      description: "ID of the vector to update",
+    },
+    {
+      name: "update",
+      type: "object",
+      description: "Update parameters",
+    },
+    {
+      name: "update.vector",
+      type: "number[]",
+      isOptional: true,
+      description: "New vector values to update",
+    },
+    {
+      name: "update.metadata",
+      type: "Record<string, any>",
+      isOptional: true,
+      description: "New metadata to update",
+    },
+  ]}
+/>
+
+### deleteIndexById()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index containing the vector",
+    },
+    {
+      name: "id",
+      type: "string",
+      description: "ID of the vector to delete",
+    },
+  ]}
+/>
+
+## Response Types
+
+Query results are returned in this format:
+
+```typescript copy
+interface QueryResult {
+  id: string;
+  score: number;
+  metadata: Record<string, any>;
+  vector?: number[]; // Only included if includeVector is true
+}
+```
+
+## Error Handling
+
+The store throws typed errors that can be caught:
+
+```typescript copy
+try {
+  await store.query({
+    indexName: "index_name",
+    queryVector: queryVector,
+  });
+} catch (error) {
+  if (error instanceof VectorStoreError) {
+    console.log(error.code); // 'connection_failed' | 'invalid_dimension' | etc
+    console.log(error.details); // Additional error context
+  }
+}
+```
+
+### Environment Variables
+
+Required environment variables:
+
+- `PINECONE_API_KEY`: Your Pinecone API key
+- `PINECONE_ENVIRONMENT`: Pinecone environment (e.g., 'us-west1-gcp')
+
+## Hybrid Search
+
+Pinecone supports hybrid search by combining dense and sparse vectors. To use hybrid search:
+
+1. Create an index with `metric: 'dotproduct'`
+2. During upsert, provide sparse vectors using the `sparseVectors` parameter
+3. During query, provide a sparse vector using the `sparseVector` parameter
+
+## Related
+
+- [Metadata Filters](./metadata-filters)

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

@@ -0,0 +1,236 @@
+---
+title: "Reference: Qdrant Vector Store | Vector Databases | RAG | Mastra Docs"
+description: Documentation for integrating Qdrant with Mastra, a vector similarity search engine for managing vectors and payloads.
+---
+
+# Qdrant Vector Store
+
+The QdrantVector class provides vector search using [Qdrant](https://qdrant.tech/), a vector similarity search engine.
+It provides a production-ready service with a convenient API to store, search, and manage vectors with additional payload and extended filtering support.
+
+## Constructor Options
+
+<PropertiesTable
+  content={[
+    {
+      name: "url",
+      type: "string",
+      description:
+        "REST URL of the Qdrant instance. Eg. https://xyz-example.eu-central.aws.cloud.qdrant.io:6333",
+    },
+    {
+      name: "apiKey",
+      type: "string",
+      description: "Optional Qdrant API key",
+    },
+    {
+      name: "https",
+      type: "boolean",
+      description:
+        "Whether to use TLS when setting up the connection. Recommended.",
+    },
+  ]}
+/>
+
+## Methods
+
+### createIndex()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to create",
+    },
+    {
+      name: "dimension",
+      type: "number",
+      description: "Vector dimension (must match your embedding model)",
+    },
+    {
+      name: "metric",
+      type: "'cosine' | 'euclidean' | 'dotproduct'",
+      isOptional: true,
+      defaultValue: "cosine",
+      description: "Distance metric for similarity search",
+    },
+  ]}
+/>
+
+### upsert()
+
+<PropertiesTable
+  content={[
+    {
+      name: "vectors",
+      type: "number[][]",
+      description: "Array of embedding vectors",
+    },
+    {
+      name: "metadata",
+      type: "Record<string, any>[]",
+      isOptional: true,
+      description: "Metadata for each vector",
+    },
+    {
+      name: "ids",
+      type: "string[]",
+      isOptional: true,
+      description: "Optional vector IDs (auto-generated if not provided)",
+    },
+  ]}
+/>
+
+### query()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to query",
+    },
+    {
+      name: "queryVector",
+      type: "number[]",
+      description: "Query vector to find similar vectors",
+    },
+    {
+      name: "topK",
+      type: "number",
+      isOptional: true,
+      defaultValue: "10",
+      description: "Number of results to return",
+    },
+    {
+      name: "filter",
+      type: "Record<string, any>",
+      isOptional: true,
+      description: "Metadata filters for the query",
+    },
+    {
+      name: "includeVector",
+      type: "boolean",
+      isOptional: true,
+      defaultValue: "false",
+      description: "Whether to include vectors in the results",
+    },
+  ]}
+/>
+
+### listIndexes()
+
+Returns an array of index names as strings.
+
+### describeIndex()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to describe",
+    },
+  ]}
+/>
+
+Returns:
+
+```typescript copy
+interface IndexStats {
+  dimension: number;
+  count: number;
+  metric: "cosine" | "euclidean" | "dotproduct";
+}
+```
+
+### deleteIndex()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to delete",
+    },
+  ]}
+/>
+
+### updateIndexById()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index to update",
+    },
+    {
+      name: "id",
+      type: "string",
+      description: "ID of the vector to update",
+    },
+    {
+      name: "update",
+      type: "{ vector?: number[]; metadata?: Record<string, any>; }",
+      description: "Object containing the vector and/or metadata to update",
+    },
+  ]}
+/>
+
+Updates a vector and/or its metadata in the specified index. If both vector and metadata are provided, both will be updated. If only one is provided, only that will be updated.
+
+### deleteIndexById()
+
+<PropertiesTable
+  content={[
+    {
+      name: "indexName",
+      type: "string",
+      description: "Name of the index from which to delete the vector",
+    },
+    {
+      name: "id",
+      type: "string",
+      description: "ID of the vector to delete",
+    },
+  ]}
+/>
+
+Deletes a vector from the specified index by its ID.
+
+## Response Types
+
+Query results are returned in this format:
+
+```typescript copy
+interface QueryResult {
+  id: string;
+  score: number;
+  metadata: Record<string, any>;
+  vector?: number[]; // Only included if includeVector is true
+}
+```
+
+## Error Handling
+
+The store throws typed errors that can be caught:
+
+```typescript copy
+try {
+  await store.query({
+    indexName: "index_name",
+    queryVector: queryVector,
+  });
+} catch (error) {
+  if (error instanceof VectorStoreError) {
+    console.log(error.code); // 'connection_failed' | 'invalid_dimension' | etc
+    console.log(error.details); // Additional error context
+  }
+}
+```
+
+## Related
+
+- [Metadata Filters](./metadata-filters)

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

@@ -0,0 +1,212 @@
+---
+title: "Reference: Rerank | Document Retrieval | RAG | Mastra Docs"
+description: Documentation for the rerank function in Mastra, which provides advanced reranking capabilities for vector search results.
+---
+
+# rerank()
+
+The `rerank()` function provides advanced reranking capabilities for vector search results by combining semantic relevance, vector similarity, and position-based scoring. 
+
+```typescript
+function rerank(
+  results: QueryResult[],
+  query: string,
+  modelConfig: ModelConfig,
+  options?: RerankerFunctionOptions
+): Promise<RerankResult[]>
+```
+
+## Usage Example
+
+```typescript
+import { openai } from "@ai-sdk/openai";
+import { rerank } from "@mastra/rag";
+
+const model = openai("gpt-4o-mini");
+
+const rerankedResults = await rerank(
+  vectorSearchResults,
+  "How do I deploy to production?",
+  model,
+  {
+    weights: {
+      semantic: 0.5,
+      vector: 0.3,
+      position: 0.2
+    },
+    topK: 3
+  }
+);
+```
+
+## Parameters
+
+<PropertiesTable
+  content={[
+    {
+      name: "results",
+      type: "QueryResult[]",
+      description: "The vector search results to rerank",
+      isOptional: false,
+    },
+    {
+      name: "query",
+      type: "string",
+      description: "The search query text used to evaluate relevance",
+      isOptional: false,
+    },
+    {
+      name: "model",
+      type: "MastraLanguageModel",
+      description: "The language Model to use for reranking",
+      isOptional: false,
+    },
+    {
+      name: "options",
+      type: "RerankerFunctionOptions",
+      description: "Options for the reranking model",
+      isOptional: true,
+    }
+  ]}
+/>
+
+The rerank function accepts any LanguageModel from the Vercel AI SDK. When using the Cohere model `rerank-v3.5`, it will automatically use Cohere's reranking capabilities.
+
+> **Note:** For semantic scoring to work properly during re-ranking, each result must include the text content in its `metadata.text` field.
+
+### RerankerFunctionOptions
+
+<PropertiesTable
+  content={[
+    {
+      name: "weights",
+      type: "WeightConfig",
+      description: "Weights for different scoring components (must add up to 1)",
+      isOptional: true,
+      properties: [
+        {
+          type: "number",
+          parameters: [
+            {
+              name: "semantic",
+              description: "Weight for semantic relevance",
+              isOptional: true,
+              type: "number (default: 0.4)",
+            }
+          ]
+        },
+        {
+          type: "number",
+          parameters: [
+            {
+              name: "vector",
+              description: "Weight for vector similarity",
+              isOptional: true,
+              type: "number (default: 0.4)",
+            }
+          ]
+        },
+        {
+          type: "number",
+          parameters: [
+            {
+              name: "position",
+              description: "Weight for position-based scoring",
+              isOptional: true,
+              type: "number (default: 0.2)",
+            }
+          ]
+        }
+      ],
+    },
+    {
+      name: "queryEmbedding",
+      type: "number[]",
+      description: "Embedding of the query",
+      isOptional: true,
+    },
+    {
+      name: "topK",
+      type: "number",
+      description: "Number of top results to return",
+      isOptional: true,
+      defaultValue: "3",
+    }
+  ]}
+/>
+
+## Returns
+
+The function returns an array of `RerankResult` objects:
+
+<PropertiesTable
+  content={[
+    {
+      name: "result",
+      type: "QueryResult",
+      description: "The original query result",
+    },
+    {
+      name: "score",
+      type: "number",
+      description: "Combined reranking score (0-1)",
+    },
+    {
+      name: "details",
+      type: "ScoringDetails",
+      description: "Detailed scoring information",
+    }
+  ]}
+/>
+
+### ScoringDetails
+
+<PropertiesTable
+  content={[
+    {
+      name: "semantic",
+      type: "number",
+      description: "Semantic relevance score (0-1)",
+    },
+    {
+      name: "vector",
+      type: "number",
+      description: "Vector similarity score (0-1)",
+    },
+    {
+      name: "position",
+      type: "number",
+      description: "Position-based score (0-1)",
+    },
+    {
+      name: "queryAnalysis",
+      type: "object",
+      description: "Query analysis details",
+      isOptional: true,
+      properties: [
+        {
+          type: "number",
+          parameters: [
+            {
+              name: "magnitude",
+              description: "Magnitude of the query",
+            }
+          ]
+        },
+        {
+          type: "number[]",
+          parameters: [
+            {
+              name: "dominantFeatures",
+              description: "Dominant features of the query",
+            }
+          ]
+        }
+      ]
+    }
+  ]}
+/>
+
+## Related
+
+- [createVectorQueryTool](../tools/vector-query-tool)