@mastra/rag 0.0.0-commonjs-20250227130920

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,620 @@
+import { createTool } from '@mastra/core/tools';
+import { Document as Document_2 } from 'llamaindex';
+import type { EmbeddingModel } from 'ai';
+import type { KeywordExtractPrompt } from 'llamaindex';
+import type { LanguageModelV1 } from 'ai';
+import type { LLM } from 'llamaindex';
+import type { MastraVector } from '@mastra/core/vector';
+import type { QueryResult } from '@mastra/core/vector';
+import type { QuestionExtractPrompt } from 'llamaindex';
+import type { SummaryPrompt } from 'llamaindex';
+import type { TiktokenEncoding } from 'js-tiktoken';
+import type { TiktokenModel } from 'js-tiktoken';
+import type { TitleCombinePrompt } from 'llamaindex';
+import type { TitleExtractorPrompt } from 'llamaindex';
+
+/**
+ * Vector store specific prompts that detail supported operators and examples.
+ * These prompts help users construct valid filters for each vector store.
+ */
+declare const ASTRA_PROMPT = "When querying Astra, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n- $all: Match all values in array\n  Example: { \"tags\": { \"$all\": [\"premium\", \"sale\"] } }\n\nLogical Operators:\n- $and: Logical AND (can be implicit or explicit)\n  Implicit Example: { \"price\": { \"$gt\": 100 }, \"category\": \"electronics\" }\n  Explicit Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n- $not: Logical NOT\n  Example: { \"$not\": { \"category\": \"electronics\" } }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nSpecial Operators:\n- $size: Array length check\n  Example: { \"tags\": { \"$size\": 2 } }\n\nRestrictions:\n- Regex patterns are not supported\n- Only $and, $or, and $not logical operators are supported\n- Nested fields are supported using dot notation\n- Multiple conditions on the same field are supported with both implicit and explicit $and\n- Empty arrays in $in/$nin will return no results\n- A non-empty array is required for $all operator\n- Only logical operators ($and, $or, $not) can be used at the top level\n- All other operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- $not operator:\n  - Must be an object\n  - Cannot be empty\n  - Can be used at field level or top level\n  - Valid: { \"$not\": { \"field\": \"value\" } }\n  - Valid: { \"field\": { \"$not\": { \"$eq\": \"value\" } } }\n- Other logical operators ($and, $or):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\n\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"tags\": { \"$all\": [\"premium\"] } },\n    { \"rating\": { \"$exists\": true, \"$gt\": 4 } },\n    { \"$or\": [\n      { \"stock\": { \"$gt\": 0 } },\n      { \"preorder\": true }\n    ]}\n  ]\n}";
+export { ASTRA_PROMPT }
+export { ASTRA_PROMPT as ASTRA_PROMPT_alias_1 }
+
+export declare class CharacterTransformer extends TextTransformer {
+    protected separator: string;
+    protected isSeparatorRegex: boolean;
+    constructor({ separator, isSeparatorRegex, options, }: {
+        separator?: string;
+        isSeparatorRegex?: boolean;
+        options?: {
+            size?: number;
+            overlap?: number;
+            lengthFunction?: (text: string) => number;
+            keepSeparator?: boolean | 'start' | 'end';
+            addStartIndex?: boolean;
+            stripWhitespace?: boolean;
+        };
+    });
+    splitText({ text }: {
+        text: string;
+    }): string[];
+    private __splitChunk;
+}
+
+declare const CHROMA_PROMPT = "When querying Chroma, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n\nLogical Operators:\n- $and: Logical AND\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n\nRestrictions:\n- Regex patterns are not supported\n- Element operators are not supported\n- Only $and and $or logical operators are supported\n- Nested fields are supported using dot notation\n- Multiple conditions on the same field are supported with both implicit and explicit $and\n- Empty arrays in $in/$nin will return no results\n- If multiple top-level fields exist, they're wrapped in $and\n- Only logical operators ($and, $or) can be used at the top level\n- All other operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n  Invalid: { \"$in\": [...] }\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- Logical operators ($and, $or):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"$or\": [\n      { \"inStock\": true },\n      { \"preorder\": true }\n    ]}\n  ]\n}";
+export { CHROMA_PROMPT }
+export { CHROMA_PROMPT as CHROMA_PROMPT_alias_1 }
+
+declare type ChunkOptions = {
+    headers?: [string, string][];
+    returnEachLine?: boolean;
+    sections?: [string, string][];
+    separator?: string;
+    separators?: string[];
+    isSeparatorRegex?: boolean;
+    size?: number;
+    maxSize?: number;
+    minSize?: number;
+    overlap?: number;
+    lengthFunction?: (text: string) => number;
+    keepSeparator?: boolean | 'start' | 'end';
+    addStartIndex?: boolean;
+    stripWhitespace?: boolean;
+    language?: Language;
+    ensureAscii?: boolean;
+    convertLists?: boolean;
+    encodingName?: TiktokenEncoding;
+    modelName?: TiktokenModel;
+    allowedSpecial?: Set<string> | 'all';
+    disallowedSpecial?: Set<string> | 'all';
+    stripHeaders?: boolean;
+};
+export { ChunkOptions }
+export { ChunkOptions as ChunkOptions_alias_1 }
+
+declare interface ChunkParams extends ChunkOptions {
+    strategy?: ChunkStrategy;
+    extract?: ExtractParams;
+}
+export { ChunkParams }
+export { ChunkParams as ChunkParams_alias_1 }
+
+declare type ChunkStrategy = 'recursive' | 'character' | 'token' | 'markdown' | 'html' | 'json' | 'latex';
+export { ChunkStrategy }
+export { ChunkStrategy as ChunkStrategy_alias_1 }
+
+declare const createDocumentChunkerTool: ({ doc, params, }: {
+    doc: MDocument;
+    params?: ChunkParams;
+}) => ReturnType<typeof createTool>;
+export { createDocumentChunkerTool }
+export { createDocumentChunkerTool as createDocumentChunkerTool_alias_1 }
+export { createDocumentChunkerTool as createDocumentChunkerTool_alias_2 }
+
+declare const createGraphRAGTool: ({ vectorStoreName, indexName, model, enableFilter, graphOptions, id, description, }: {
+    vectorStoreName: string;
+    indexName: string;
+    model: EmbeddingModel<string>;
+    enableFilter?: boolean;
+    graphOptions?: {
+        dimension?: number;
+        randomWalkSteps?: number;
+        restartProb?: number;
+        threshold?: number;
+    };
+    id?: string;
+    description?: string;
+}) => ReturnType<typeof createTool>;
+export { createGraphRAGTool }
+export { createGraphRAGTool as createGraphRAGTool_alias_1 }
+export { createGraphRAGTool as createGraphRAGTool_alias_2 }
+
+declare const createVectorQueryTool: ({ vectorStoreName, indexName, model, enableFilter, reranker, id, description, }: {
+    vectorStoreName: string;
+    indexName: string;
+    model: EmbeddingModel<string>;
+    enableFilter?: boolean;
+    reranker?: RerankConfig;
+    id?: string;
+    description?: string;
+}) => ReturnType<typeof createTool>;
+export { createVectorQueryTool }
+export { createVectorQueryTool as createVectorQueryTool_alias_1 }
+export { createVectorQueryTool as createVectorQueryTool_alias_2 }
+
+declare const defaultFilter = "You MUST generate for each query:\n    filter: query filter (REQUIRED) (Default: {})\n        - Generate filter based on user's explicit query intent\n        - Must be valid JSON string\n\n    Notes: \n    - If user provides a valid filter, use the filter provided\n    - If user does not specify filter or provides an invalid filter, use default filter: {}\n";
+export { defaultFilter }
+export { defaultFilter as defaultFilter_alias_1 }
+export { defaultFilter as defaultFilter_alias_2 }
+
+declare const defaultGraphRagDescription: (vectorStoreName: string, indexName: string) => string;
+export { defaultGraphRagDescription }
+export { defaultGraphRagDescription as defaultGraphRagDescription_alias_1 }
+export { defaultGraphRagDescription as defaultGraphRagDescription_alias_2 }
+
+declare const defaultTopK = "You MUST generate for each query:\n    topK: number of results to return (REQUIRED) (Default: 10)\n        - Generate topK based on exactly what user specifies\n        - must be a valid number\n\n    Notes: \n    - If user provides a valid topK, use the topK provided\n    - If user does not specify topK or provides an invalid topK, use default topK: 10\n";
+export { defaultTopK }
+export { defaultTopK as defaultTopK_alias_1 }
+export { defaultTopK as defaultTopK_alias_2 }
+
+declare const defaultVectorQueryDescription: (vectorStoreName: string, indexName: string) => string;
+export { defaultVectorQueryDescription }
+export { defaultVectorQueryDescription as defaultVectorQueryDescription_alias_1 }
+export { defaultVectorQueryDescription as defaultVectorQueryDescription_alias_2 }
+
+declare type ExtractParams = {
+    title?: TitleExtractorsArgs | boolean;
+    summary?: SummaryExtractArgs | boolean;
+    questions?: QuestionAnswerExtractArgs | boolean;
+    keywords?: boolean | Record<string, any>;
+};
+export { ExtractParams }
+export { ExtractParams as ExtractParams_alias_1 }
+
+export declare interface GraphChunk {
+    text: string;
+    metadata: Record<string, any>;
+}
+
+export declare interface GraphEdge {
+    source: string;
+    target: string;
+    weight: number;
+    type: SupportedEdgeType;
+}
+
+export declare interface GraphEmbedding {
+    vector: number[];
+}
+
+export declare interface GraphNode {
+    id: string;
+    content: string;
+    embedding?: number[];
+    metadata?: Record<string, any>;
+}
+
+declare class GraphRAG {
+    private nodes;
+    private edges;
+    private dimension;
+    private threshold;
+    constructor(dimension?: number, threshold?: number);
+    addNode(node: GraphNode): void;
+    addEdge(edge: GraphEdge): void;
+    getNodes(): GraphNode[];
+    getEdges(): GraphEdge[];
+    getEdgesByType(type: string): GraphEdge[];
+    clear(): void;
+    updateNodeContent(id: string, newContent: string): void;
+    private getNeighbors;
+    private cosineSimilarity;
+    createGraph(chunks: GraphChunk[], embeddings: GraphEmbedding[]): void;
+    private selectWeightedNeighbor;
+    private randomWalkWithRestart;
+    query({ query, topK, randomWalkSteps, restartProb, }: {
+        query: number[];
+        topK?: number;
+        randomWalkSteps?: number;
+        restartProb?: number;
+    }): RankedNode[];
+}
+export { GraphRAG }
+export { GraphRAG as GraphRAG_alias_1 }
+
+export declare class HTMLHeaderTransformer {
+    private headersToSplitOn;
+    private returnEachElement;
+    constructor(headersToSplitOn: [string, string][], returnEachElement?: boolean);
+    splitText({ text }: {
+        text: string;
+    }): Document_2[];
+    private getXPath;
+    private getTextContent;
+    private aggregateElementsToChunks;
+    createDocuments(texts: string[], metadatas?: Record<string, any>[]): Document_2[];
+    transformDocuments(documents: Document_2[]): Document_2[];
+}
+
+export declare class HTMLSectionTransformer {
+    private headersToSplitOn;
+    private options;
+    constructor(headersToSplitOn: [string, string][], options?: Record<string, any>);
+    splitText(text: string): Document_2[];
+    private getXPath;
+    private splitHtmlByHeaders;
+    splitDocuments(documents: Document_2[]): Promise<Document_2[]>;
+    createDocuments(texts: string[], metadatas?: Record<string, any>[]): Document_2[];
+    transformDocuments(documents: Document_2[]): Document_2[];
+}
+
+declare type KeywordExtractArgs = {
+    llm?: LLM;
+    keywords?: number;
+    promptTemplate?: KeywordExtractPrompt['template'];
+};
+export { KeywordExtractArgs }
+export { KeywordExtractArgs as KeywordExtractArgs_alias_1 }
+
+declare enum Language {
+    CPP = "cpp",
+    GO = "go",
+    JAVA = "java",
+    KOTLIN = "kotlin",
+    JS = "js",
+    TS = "ts",
+    PHP = "php",
+    PROTO = "proto",
+    PYTHON = "python",
+    RST = "rst",
+    RUBY = "ruby",
+    RUST = "rust",
+    SCALA = "scala",
+    SWIFT = "swift",
+    MARKDOWN = "markdown",
+    LATEX = "latex",
+    HTML = "html",
+    SOL = "sol",
+    CSHARP = "csharp",
+    COBOL = "cobol",
+    C = "c",
+    LUA = "lua",
+    PERL = "perl",
+    HASKELL = "haskell",
+    ELIXIR = "elixir",
+    POWERSHELL = "powershell"
+}
+export { Language }
+export { Language as Language_alias_1 }
+
+export declare class LatexTransformer extends RecursiveCharacterTransformer {
+    constructor(options?: {
+        size?: number;
+        overlap?: number;
+        lengthFunction?: (text: string) => number;
+        keepSeparator?: boolean | 'start' | 'end';
+        addStartIndex?: boolean;
+        stripWhitespace?: boolean;
+    });
+}
+
+declare const LIBSQL_PROMPT = "When querying LibSQL Vector, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n- $all: Match all values in array\n  Example: { \"tags\": { \"$all\": [\"premium\", \"sale\"] } }\n- $elemMatch: Match array elements that meet all specified conditions\n  Example: { \"items\": { \"$elemMatch\": { \"price\": { \"$gt\": 100 } } } }\n- $contains: Check if array contains value\n  Example: { \"tags\": { \"$contains\": \"premium\" } }\n\nLogical Operators:\n- $and: Logical AND (implicit when using multiple conditions)\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n- $not: Logical NOT\n  Example: { \"$not\": { \"category\": \"electronics\" } }\n- $nor: Logical NOR\n  Example: { \"$nor\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nSpecial Operators:\n- $size: Array length check\n  Example: { \"tags\": { \"$size\": 2 } }\n\nRestrictions:\n- Regex patterns are not supported\n- Direct RegExp patterns will throw an error\n- Nested fields are supported using dot notation\n- Multiple conditions on the same field are supported with both implicit and explicit $and\n- Array operations work on array fields only\n- Basic operators handle array values as JSON strings\n- Empty arrays in conditions are handled gracefully\n- Only logical operators ($and, $or, $not, $nor) can be used at the top level\n- All other operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n  Invalid: { \"$contains\": \"value\" }\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- $not operator:\n  - Must be an object\n  - Cannot be empty\n  - Can be used at field level or top level\n  - Valid: { \"$not\": { \"field\": \"value\" } }\n  - Valid: { \"field\": { \"$not\": { \"$eq\": \"value\" } } }\n- Other logical operators ($and, $or, $nor):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\n- $elemMatch requires an object with conditions\n  Valid: { \"array\": { \"$elemMatch\": { \"field\": \"value\" } } }\n  Invalid: { \"array\": { \"$elemMatch\": \"value\" } }\n\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"tags\": { \"$all\": [\"premium\", \"sale\"] } },\n    { \"items\": { \"$elemMatch\": { \"price\": { \"$gt\": 50 }, \"inStock\": true } } },\n    { \"$or\": [\n      { \"stock\": { \"$gt\": 0 } },\n      { \"preorder\": true }\n    ]}\n  ]\n}";
+export { LIBSQL_PROMPT }
+export { LIBSQL_PROMPT as LIBSQL_PROMPT_alias_1 }
+
+export declare class MarkdownHeaderTransformer {
+    private headersToSplitOn;
+    private returnEachLine;
+    private stripHeaders;
+    constructor(headersToSplitOn: [string, string][], returnEachLine?: boolean, stripHeaders?: boolean);
+    private aggregateLinesToChunks;
+    splitText({ text }: {
+        text: string;
+    }): Document_2[];
+    createDocuments(texts: string[], metadatas?: Record<string, any>[]): Document_2[];
+    transformDocuments(documents: Document_2[]): Document_2[];
+}
+
+export declare class MarkdownTransformer extends RecursiveCharacterTransformer {
+    constructor(options?: {
+        chunkSize?: number;
+        chunkOverlap?: number;
+        lengthFunction?: (text: string) => number;
+        keepSeparator?: boolean | 'start' | 'end';
+        addStartIndex?: boolean;
+        stripWhitespace?: boolean;
+    });
+}
+
+declare class MDocument {
+    private chunks;
+    private type;
+    constructor({ docs, type }: {
+        docs: {
+            text: string;
+            metadata?: Record<string, any>;
+        }[];
+        type: string;
+    });
+    extractMetadata({ title, summary, questions, keywords }: ExtractParams): Promise<MDocument>;
+    static fromText(text: string, metadata?: Record<string, any>): MDocument;
+    static fromHTML(html: string, metadata?: Record<string, any>): MDocument;
+    static fromMarkdown(markdown: string, metadata?: Record<string, any>): MDocument;
+    static fromJSON(jsonString: string, metadata?: Record<string, any>): MDocument;
+    private defaultStrategy;
+    private chunkBy;
+    chunkRecursive(options?: ChunkOptions): Promise<void>;
+    chunkCharacter(options?: ChunkOptions): Promise<void>;
+    chunkHTML(options?: ChunkOptions): Promise<void>;
+    chunkJSON(options?: ChunkOptions): Promise<void>;
+    chunkLatex(options?: ChunkOptions): Promise<void>;
+    chunkToken(options?: ChunkOptions): Promise<void>;
+    chunkMarkdown(options?: ChunkOptions): Promise<void>;
+    chunk(params?: ChunkParams): Promise<Document_2[]>;
+    getDocs(): Document_2[];
+    getText(): string[];
+    getMetadata(): Record<string, any>[];
+}
+export { MDocument }
+export { MDocument as MDocument_alias_1 }
+export { MDocument as MDocument_alias_2 }
+
+declare const PGVECTOR_PROMPT = "When querying PG Vector, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n- $all: Match all values in array\n  Example: { \"tags\": { \"$all\": [\"premium\", \"sale\"] } }\n- $elemMatch: Match array elements that meet all specified conditions\n  Example: { \"items\": { \"$elemMatch\": { \"price\": { \"$gt\": 100 } } } }\n- $contains: Check if array contains value\n  Example: { \"tags\": { \"$contains\": \"premium\" } }\n\nLogical Operators:\n- $and: Logical AND\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n- $not: Logical NOT\n  Example: { \"$not\": { \"category\": \"electronics\" } }\n- $nor: Logical NOR\n  Example: { \"$nor\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nSpecial Operators:\n- $size: Array length check\n  Example: { \"tags\": { \"$size\": 2 } }\n- $regex: Pattern matching (PostgreSQL regex syntax)\n  Example: { \"name\": { \"$regex\": \"^iphone\" } }\n- $options: Regex options (used with $regex)\n  Example: { \"name\": { \"$regex\": \"iphone\", \"$options\": \"i\" } }\n\nRestrictions:\n- Direct RegExp patterns are supported\n- Nested fields are supported using dot notation\n- Multiple conditions on the same field are supported with both implicit and explicit $and\n- Array operations work on array fields only\n- Regex patterns must follow PostgreSQL syntax\n- Empty arrays in conditions are handled gracefully\n- Only logical operators ($and, $or, $not, $nor) can be used at the top level\n- All other operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n  Invalid: { \"$regex\": \"pattern\" }\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- $not operator:\n  - Must be an object\n  - Cannot be empty\n  - Can be used at field level or top level\n  - Valid: { \"$not\": { \"field\": \"value\" } }\n  - Valid: { \"field\": { \"$not\": { \"$eq\": \"value\" } } }\n- Other logical operators ($and, $or, $nor):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\n- $elemMatch requires an object with conditions\n  Valid: { \"array\": { \"$elemMatch\": { \"field\": \"value\" } } }\n  Invalid: { \"array\": { \"$elemMatch\": \"value\" } }\n\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"tags\": { \"$all\": [\"premium\", \"sale\"] } },\n    { \"items\": { \"$elemMatch\": { \"price\": { \"$gt\": 50 }, \"inStock\": true } } },\n    { \"$or\": [\n      { \"name\": { \"$regex\": \"^iphone\", \"$options\": \"i\" } },\n      { \"description\": { \"$regex\": \".*apple.*\" } }\n    ]}\n  ]\n}";
+export { PGVECTOR_PROMPT }
+export { PGVECTOR_PROMPT as PGVECTOR_PROMPT_alias_1 }
+
+declare const PINECONE_PROMPT = "When querying Pinecone, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n- $all: Match all values in array\n  Example: { \"tags\": { \"$all\": [\"premium\", \"sale\"] } }\n\nLogical Operators:\n- $and: Logical AND (can be implicit or explicit)\n  Implicit Example: { \"price\": { \"$gt\": 100 }, \"category\": \"electronics\" }\n  Explicit Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nRestrictions:\n- Regex patterns are not supported\n- Only $and and $or logical operators are supported at the top level\n- Empty arrays in $in/$nin will return no results\n- A non-empty array is required for $all operator\n- Nested fields are supported using dot notation\n- Multiple conditions on the same field are supported with both implicit and explicit $and\n- At least one key-value pair is required in filter object\n- Empty objects and undefined values are treated as no filter\n- Invalid types in comparison operators will throw errors\n- All non-logical operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- Logical operators ($and, $or):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gte\": 100, \"$lte\": 1000 } },\n    { \"tags\": { \"$all\": [\"premium\", \"sale\"] } },\n    { \"rating\": { \"$exists\": true, \"$gt\": 4 } },\n    { \"$or\": [\n      { \"stock\": { \"$gt\": 0 } },\n      { \"preorder\": true }\n    ]}\n  ]\n}";
+export { PINECONE_PROMPT }
+export { PINECONE_PROMPT as PINECONE_PROMPT_alias_1 }
+
+declare const QDRANT_PROMPT = "When querying Qdrant, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n\nLogical Operators:\n- $and: Logical AND (implicit when using multiple conditions)\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n- $not: Logical NOT\n  Example: { \"$not\": { \"category\": \"electronics\" } }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nSpecial Operators:\n- $regex: Pattern matching\n  Example: { \"name\": { \"$regex\": \"iphone.*\" } }\n- $count: Array length/value count\n  Example: { \"tags\": { \"$count\": { \"$gt\": 2 } } }\n- $geo: Geographical filters (supports radius, box, polygon)\n  Example: {\n    \"location\": {\n      \"$geo\": {\n        \"type\": \"radius\",\n        \"center\": { \"lat\": 52.5, \"lon\": 13.4 },\n        \"radius\": 10000\n      }\n    }\n  }\n- $hasId: Match specific document IDs\n  Example: { \"$hasId\": [\"doc1\", \"doc2\"] }\n- $hasVector: Check vector existence\n  Example: { \"$hasVector\": \"\" }\n- $datetime: RFC 3339 datetime range\n  Example: {\n    \"created_at\": {\n      \"$datetime\": {\n        \"range\": {\n          \"gt\": \"2024-01-01T00:00:00Z\",\n          \"lt\": \"2024-12-31T23:59:59Z\"\n        }\n      }\n    }\n  }\n- $null: Check for null values\n  Example: { \"field\": { \"$null\": true } }\n- $empty: Check for empty values\n  Example: { \"array\": { \"$empty\": true } }\n- $nested: Nested object filters\n  Example: {\n    \"items[]\": {\n      \"$nested\": {\n        \"price\": { \"$gt\": 100 },\n        \"stock\": { \"$gt\": 0 }\n      }\n    }\n  }\n\nRestrictions:\n- Only logical operators ($and, $or, $not) and collection operators ($hasId, $hasVector) can be used at the top level\n- All other operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Valid: { \"$hasId\": [...] }\n  Invalid: { \"$gt\": 100 }\n- Nested fields are supported using dot notation\n- Array fields with nested objects use [] suffix: \"items[]\"\n- Geo filtering requires specific format for radius, box, or polygon\n- Datetime values must be in RFC 3339 format\n- Empty arrays in conditions are handled as empty values\n- Null values are handled with $null operator\n- Empty values are handled with $empty operator\n- $regex uses standard regex syntax\n- $count can only be used with numeric comparison operators\n- $nested requires an object with conditions\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- $not operator:\n  - Must be an object\n  - Cannot be empty\n  - Can be used at field level or top level\n  - Valid: { \"$not\": { \"field\": \"value\" } }\n  - Valid: { \"field\": { \"$not\": { \"$eq\": \"value\" } } }\n- Other logical operators ($and, $or):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\"] } },\n    { \"price\": { \"$gt\": 100 } },\n    { \"location\": {\n      \"$geo\": {\n        \"type\": \"radius\",\n        \"center\": { \"lat\": 52.5, \"lon\": 13.4 },\n        \"radius\": 5000\n      }\n    }},\n    { \"items[]\": {\n      \"$nested\": {\n        \"price\": { \"$gt\": 50 },\n        \"stock\": { \"$gt\": 0 }\n      }\n    }},\n    { \"created_at\": {\n      \"$datetime\": {\n        \"range\": {\n          \"gt\": \"2024-01-01T00:00:00Z\"\n        }\n      }\n    }},\n    { \"$or\": [\n      { \"status\": { \"$ne\": \"discontinued\" } },\n      { \"clearance\": true }\n    ]}\n  ]\n}";
+export { QDRANT_PROMPT }
+export { QDRANT_PROMPT as QDRANT_PROMPT_alias_1 }
+
+declare type QuestionAnswerExtractArgs = {
+    llm?: LLM;
+    questions?: number;
+    promptTemplate?: QuestionExtractPrompt['template'];
+    embeddingOnly?: boolean;
+};
+export { QuestionAnswerExtractArgs }
+export { QuestionAnswerExtractArgs as QuestionAnswerExtractArgs_alias_1 }
+
+declare interface RankedNode extends GraphNode {
+    score: number;
+}
+
+export declare class RecursiveCharacterTransformer extends TextTransformer {
+    protected separators: string[];
+    protected isSeparatorRegex: boolean;
+    constructor({ separators, isSeparatorRegex, options, }: {
+        separators?: string[];
+        isSeparatorRegex?: boolean;
+        options?: ChunkOptions;
+    });
+    private _splitText;
+    splitText({ text }: {
+        text: string;
+    }): string[];
+    static fromLanguage(language: Language, options?: {
+        size?: number;
+        chunkOverlap?: number;
+        lengthFunction?: (text: string) => number;
+        keepSeparator?: boolean | 'start' | 'end';
+        addStartIndex?: boolean;
+        stripWhitespace?: boolean;
+    }): RecursiveCharacterTransformer;
+    static getSeparatorsForLanguage(language: Language): string[];
+}
+
+export declare class RecursiveJsonTransformer {
+    private maxSize;
+    private minSize;
+    constructor({ maxSize, minSize }: {
+        maxSize: number;
+        minSize?: number;
+    });
+    private static jsonSize;
+    /**
+     * Transform JSON data while handling circular references
+     */
+    transform(data: Record<string, any>): Record<string, any>;
+    /**
+     * Set a value in a nested dictionary based on the given path
+     */
+    private static setNestedDict;
+    /**
+     * Convert lists in the JSON structure to dictionaries with index-based keys
+     */
+    private listToDictPreprocessing;
+    /**
+     * Split json into maximum size dictionaries while preserving structure
+     */
+    private jsonSplit;
+    /**
+     * Splits JSON into a list of JSON chunks
+     */
+    splitJson({ jsonData, convertLists, }: {
+        jsonData: Record<string, any>;
+        convertLists?: boolean;
+    }): Record<string, any>[];
+    private escapeNonAscii;
+    /**
+     * Splits JSON into a list of JSON formatted strings
+     */
+    splitText({ jsonData, convertLists, ensureAscii, }: {
+        jsonData: Record<string, any>;
+        convertLists?: boolean;
+        ensureAscii?: boolean;
+    }): string[];
+    /**
+     * Create documents from a list of json objects
+     */
+    createDocuments({ texts, convertLists, ensureAscii, metadatas, }: {
+        texts: string[];
+        convertLists?: boolean;
+        ensureAscii?: boolean;
+        metadatas?: Record<string, any>[];
+    }): Document_2[];
+    transformDocuments({ ensureAscii, documents, convertLists, }: {
+        ensureAscii?: boolean;
+        convertLists?: boolean;
+        documents: Document_2[];
+    }): Document_2[];
+}
+
+declare function rerank(results: QueryResult[], query: string, model: LanguageModelV1, options: RerankerFunctionOptions): Promise<RerankResult[]>;
+export { rerank }
+export { rerank as rerank_alias_1 }
+
+declare interface RerankConfig {
+    options?: RerankerOptions;
+    model: LanguageModelV1;
+}
+export { RerankConfig }
+export { RerankConfig as RerankConfig_alias_1 }
+
+declare interface RerankerFunctionOptions {
+    weights?: WeightConfig;
+    queryEmbedding?: number[];
+    topK?: number;
+}
+export { RerankerFunctionOptions }
+export { RerankerFunctionOptions as RerankerFunctionOptions_alias_1 }
+
+declare interface RerankerOptions {
+    weights?: WeightConfig;
+    topK?: number;
+}
+export { RerankerOptions }
+export { RerankerOptions as RerankerOptions_alias_1 }
+
+declare interface RerankResult {
+    result: QueryResult;
+    score: number;
+    details: ScoringDetails;
+}
+export { RerankResult }
+export { RerankResult as RerankResult_alias_1 }
+
+declare interface ScoringDetails {
+    semantic: number;
+    vector: number;
+    position: number;
+    queryAnalysis?: {
+        magnitude: number;
+        dominantFeatures: number[];
+    };
+}
+
+export declare function splitTextOnTokens({ text, tokenizer }: {
+    text: string;
+    tokenizer: Tokenizer;
+}): string[];
+
+declare type SummaryExtractArgs = {
+    llm?: LLM;
+    summaries?: string[];
+    promptTemplate?: SummaryPrompt['template'];
+};
+export { SummaryExtractArgs }
+export { SummaryExtractArgs as SummaryExtractArgs_alias_1 }
+
+/**
+ * TODO: GraphRAG Enhancements
+ *  - Add support for more edge types (sequential, hierarchical, citation, etc)
+ *  - Allow for custom edge types
+ *  - Utilize metadata for richer connections
+ *  - Improve graph traversal and querying using types
+ */
+declare type SupportedEdgeType = 'semantic';
+
+export declare abstract class TextTransformer implements Transformer_2 {
+    protected size: number;
+    protected overlap: number;
+    protected lengthFunction: (text: string) => number;
+    protected keepSeparator: boolean | 'start' | 'end';
+    protected addStartIndex: boolean;
+    protected stripWhitespace: boolean;
+    constructor({ size, overlap, lengthFunction, keepSeparator, addStartIndex, stripWhitespace, }: ChunkOptions);
+    setAddStartIndex(value: boolean): void;
+    abstract splitText({ text }: {
+        text: string;
+    }): string[];
+    createDocuments(texts: string[], metadatas?: Record<string, any>[]): Document_2[];
+    splitDocuments(documents: Document_2[]): Document_2[];
+    transformDocuments(documents: Document_2[]): Document_2[];
+    protected joinDocs(docs: string[], separator: string): string | null;
+    protected mergeSplits(splits: string[], separator: string): string[];
+}
+
+declare type TitleExtractorsArgs = {
+    llm?: LLM;
+    nodes?: number;
+    nodeTemplate?: TitleExtractorPrompt['template'];
+    combineTemplate?: TitleCombinePrompt['template'];
+};
+export { TitleExtractorsArgs }
+export { TitleExtractorsArgs as TitleExtractorsArgs_alias_1 }
+
+declare interface Tokenizer {
+    overlap: number;
+    tokensPerChunk: number;
+    decode: (tokens: number[]) => string;
+    encode: (text: string) => number[];
+}
+
+export declare class TokenTransformer extends TextTransformer {
+    private tokenizer;
+    private allowedSpecial;
+    private disallowedSpecial;
+    constructor({ encodingName, modelName, allowedSpecial, disallowedSpecial, options, }: {
+        encodingName: TiktokenEncoding;
+        modelName?: TiktokenModel;
+        allowedSpecial?: Set<string> | 'all';
+        disallowedSpecial?: Set<string> | 'all';
+        options: {
+            size?: number;
+            overlap?: number;
+            lengthFunction?: (text: string) => number;
+            keepSeparator?: boolean | 'start' | 'end';
+            addStartIndex?: boolean;
+            stripWhitespace?: boolean;
+        };
+    });
+    splitText({ text }: {
+        text: string;
+    }): string[];
+    static fromTikToken({ encodingName, modelName, options, }: {
+        encodingName?: TiktokenEncoding;
+        modelName?: TiktokenModel;
+        options?: {
+            size?: number;
+            overlap?: number;
+            allowedSpecial?: Set<string> | 'all';
+            disallowedSpecial?: Set<string> | 'all';
+        };
+    }): TokenTransformer;
+}
+
+declare interface Transformer_2 {
+    transformDocuments(documents: Document_2[]): Document_2[];
+}
+export { Transformer_2 as Transformer }
+
+declare const UPSTASH_PROMPT = "When querying Upstash Vector, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" } or { \"category\": { \"$eq\": \"electronics\" } }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n- $all: Matches all values in array\n  Example: { \"tags\": { \"$all\": [\"premium\", \"new\"] } }\n\nLogical Operators:\n- $and: Logical AND (implicit when using multiple conditions)\n  Example: { \"$and\": [{ \"price\": { \"$gt\": 100 } }, { \"category\": \"electronics\" }] }\n- $or: Logical OR\n  Example: { \"$or\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n- $not: Logical NOT\n  Example: { \"$not\": { \"category\": \"electronics\" } }\n- $nor: Logical NOR\n  Example: { \"$nor\": [{ \"price\": { \"$lt\": 50 } }, { \"category\": \"books\" }] }\n\nElement Operators:\n- $exists: Check if field exists\n  Example: { \"rating\": { \"$exists\": true } }\n\nSpecial Operators:\n- $regex: Pattern matching using glob syntax (only as operator, not direct RegExp)\n  Example: { \"name\": { \"$regex\": \"iphone*\" } }\n- $contains: Check if array/string contains value\n  Example: { \"tags\": { \"$contains\": \"premium\" } }\n\nRestrictions:\n- Null/undefined values are not supported in any operator\n- Empty arrays are only supported in $in/$nin operators\n- Direct RegExp patterns are not supported, use $regex with glob syntax\n- Nested fields are supported using dot notation\n- Multiple conditions on same field are combined with AND\n- String values with quotes are automatically escaped\n- Only logical operators ($and, $or, $not, $nor) can be used at the top level\n- All other operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Valid: { \"$and\": [...] }\n  Invalid: { \"$gt\": 100 }\n- $regex uses glob syntax (*, ?) not standard regex patterns\n- $contains works on both arrays and string fields\n- Logical operators must contain field conditions, not direct operators\n  Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  Invalid: { \"$and\": [{ \"$gt\": 100 }] }\n- $not operator:\n  - Must be an object\n  - Cannot be empty\n  - Can be used at field level or top level\n  - Valid: { \"$not\": { \"field\": \"value\" } }\n  - Valid: { \"field\": { \"$not\": { \"$eq\": \"value\" } } }\n- Other logical operators ($and, $or, $nor):\n  - Can only be used at top level or nested within other logical operators\n  - Can not be used on a field level, or be nested inside a field\n  - Can not be used inside an operator\n  - Valid: { \"$and\": [{ \"field\": { \"$gt\": 100 } }] }\n  - Valid: { \"$or\": [{ \"$and\": [{ \"field\": { \"$gt\": 100 } }] }] }\n  - Invalid: { \"field\": { \"$and\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$or\": [{ \"$gt\": 100 }] } }\n  - Invalid: { \"field\": { \"$gt\": { \"$and\": [{...}] } } }\nExample Complex Query:\n{\n  \"$and\": [\n    { \"category\": { \"$in\": [\"electronics\", \"computers\"] } },\n    { \"price\": { \"$gt\": 100, \"$lt\": 1000 } },\n    { \"tags\": { \"$all\": [\"premium\", \"new\"] } },\n    { \"name\": { \"$regex\": \"iphone*\" } },\n    { \"description\": { \"$contains\": \"latest\" } },\n    { \"$or\": [\n      { \"brand\": \"Apple\" },\n      { \"rating\": { \"$gte\": 4.5 } }\n    ]}\n  ]\n}";
+export { UPSTASH_PROMPT }
+export { UPSTASH_PROMPT as UPSTASH_PROMPT_alias_1 }
+
+declare const VECTORIZE_PROMPT = "When querying Vectorize, you can ONLY use the operators listed below. Any other operators will be rejected.\nImportant: Don't explain how to construct the filter - use the specified operators and fields to search the content and return relevant results.\nIf a user tries to give an explicit operator that is not supported, reject the filter entirely and let them know that the operator is not supported.\n\nBasic Comparison Operators:\n- $eq: Exact match (default when using field: value)\n  Example: { \"category\": \"electronics\" }\n- $ne: Not equal\n  Example: { \"category\": { \"$ne\": \"electronics\" } }\n- $gt: Greater than\n  Example: { \"price\": { \"$gt\": 100 } }\n- $gte: Greater than or equal\n  Example: { \"price\": { \"$gte\": 100 } }\n- $lt: Less than\n  Example: { \"price\": { \"$lt\": 100 } }\n- $lte: Less than or equal\n  Example: { \"price\": { \"$lte\": 100 } }\n\nArray Operators:\n- $in: Match any value in array\n  Example: { \"category\": { \"$in\": [\"electronics\", \"books\"] } }\n- $nin: Does not match any value in array\n  Example: { \"category\": { \"$nin\": [\"electronics\", \"books\"] } }\n\nRestrictions:\n- Regex patterns are not supported\n- Logical operators are not supported\n- Element operators are not supported\n- Fields must have a flat structure, as nested fields are not supported\n- Multiple conditions on the same field are supported\n- Empty arrays in $in/$nin will return no results\n- Filter keys cannot be longer than 512 characters\n- Filter keys cannot contain invalid characters ($, \", empty)\n- Filter size is limited to prevent oversized queries\n- Invalid types in operators return no results instead of throwing errors\n- Empty objects are accepted in filters\n- Metadata must use flat structure with dot notation (no nested objects)\n- Must explicitly create metadata indexes for filterable fields (limit 10 per index)\n- Can only effectively filter on indexed metadata fields\n- Metadata values can be strings, numbers, booleans, or homogeneous arrays\n- No operators can be used at the top level (no logical operators supported)\n- All operators must be used within a field condition\n  Valid: { \"field\": { \"$gt\": 100 } }\n  Invalid: { \"$gt\": 100 }\n  Invalid: { \"$in\": [...] }\n\nExample Complex Query:\n{\n  \"category\": { \"$in\": [\"electronics\", \"computers\"] },\n  \"price\": { \"$gte\": 100, \"$lte\": 1000 },\n  \"inStock\": true\n}";
+export { VECTORIZE_PROMPT }
+export { VECTORIZE_PROMPT as VECTORIZE_PROMPT_alias_1 }
+
+declare const vectorQuerySearch: ({ indexName, vectorStore, queryText, model, queryFilter, topK, includeVectors, maxRetries, }: VectorQuerySearchParams) => Promise<VectorQuerySearchResult>;
+export { vectorQuerySearch }
+export { vectorQuerySearch as vectorQuerySearch_alias_1 }
+
+declare interface VectorQuerySearchParams {
+    indexName: string;
+    vectorStore: MastraVector;
+    queryText: string;
+    model: EmbeddingModel<string>;
+    queryFilter?: any;
+    topK: number;
+    includeVectors?: boolean;
+    maxRetries?: number;
+}
+
+declare interface VectorQuerySearchResult {
+    results: QueryResult[];
+    queryEmbedding: number[];
+}
+
+declare type WeightConfig = {
+    semantic?: number;
+    vector?: number;
+    position?: number;
+};
+
+export { }