@llamaindex/core/vector-store/dist/index.js

LlamaIndex Core Module

import { Settings } from '../../global/dist/index.js';
import { jsonToNode, ObjectType } from '../../schema/dist/index.js';

const DEFAULT_TEXT_KEY = "text";
function validateIsFlat(obj) {
    for(const key in obj){
        if (typeof obj[key] === "object" && obj[key] !== null) {
            throw new Error(`Value for metadata ${key} must not be another object`);
        }
    }
}
function nodeToMetadata(node, removeText = false, textField = DEFAULT_TEXT_KEY, flatMetadata = false) {
    const { metadata, embedding, ...rest } = node.toMutableJSON();
    if (flatMetadata) {
        validateIsFlat(metadata);
    }
    if (removeText) {
        rest[textField] = "";
    }
    metadata["_node_content"] = JSON.stringify(rest);
    metadata["_node_type"] = node.constructor.name.replace("_", ""); // remove leading underscore to be compatible with Python
    metadata["document_id"] = node.sourceNode?.nodeId || "None";
    metadata["doc_id"] = node.sourceNode?.nodeId || "None";
    metadata["ref_doc_id"] = node.sourceNode?.nodeId || "None";
    return metadata;
}
function metadataDictToNode(metadata, options) {
    const { _node_content: nodeContent, _node_type: nodeType, document_id, doc_id, ref_doc_id, ...rest } = metadata;
    let nodeObj;
    if (!nodeContent) {
        if (options?.fallback) {
            nodeObj = options?.fallback;
        } else {
            throw new Error("Node content not found in metadata.");
        }
    } else {
        nodeObj = JSON.parse(nodeContent);
        nodeObj = {
            ...rest,
            ...options?.fallback,
            ...nodeObj
        };
        nodeObj.metadata = {
            ...options?.fallback && "metadata" in options.fallback && typeof options.fallback.metadata === "object" ? options?.fallback.metadata : {},
            ...rest
        };
    }
    // Note: we're using the name of the class stored in `_node_type`
    // and not the type attribute to reconstruct
    // the node. This way we're compatible with LlamaIndex Python
    switch(nodeType){
        case "IndexNode":
            return jsonToNode(nodeObj, ObjectType.INDEX);
        default:
            return jsonToNode(nodeObj, ObjectType.TEXT);
    }
}
const escapeLikeString = (value)=>{
    return value.replace(/[%_\\]/g, "\\$&");
};

var VectorStoreQueryMode = /*#__PURE__*/ function(VectorStoreQueryMode) {
    VectorStoreQueryMode["DEFAULT"] = "default";
    VectorStoreQueryMode["SPARSE"] = "sparse";
    VectorStoreQueryMode["HYBRID"] = "hybrid";
    // fit learners
    VectorStoreQueryMode["SVM"] = "svm";
    VectorStoreQueryMode["LOGISTIC_REGRESSION"] = "logistic_regression";
    VectorStoreQueryMode["LINEAR_REGRESSION"] = "linear_regression";
    // maximum marginal relevance
    VectorStoreQueryMode["MMR"] = "mmr";
    // for Azure AI Search
    VectorStoreQueryMode["SEMANTIC_HYBRID"] = "semantic_hybrid";
    return VectorStoreQueryMode;
}({});
var FilterOperator = /*#__PURE__*/ function(FilterOperator) {
    FilterOperator["EQ"] = "==";
    FilterOperator["IN"] = "in";
    FilterOperator["GT"] = ">";
    FilterOperator["LT"] = "<";
    FilterOperator["NE"] = "!=";
    FilterOperator["GTE"] = ">=";
    FilterOperator["LTE"] = "<=";
    FilterOperator["NIN"] = "nin";
    FilterOperator["ANY"] = "any";
    FilterOperator["ALL"] = "all";
    FilterOperator["TEXT_MATCH"] = "text_match";
    FilterOperator["CONTAINS"] = "contains";
    FilterOperator["IS_EMPTY"] = "is_empty";
    return FilterOperator;
}({});
var FilterCondition = /*#__PURE__*/ function(FilterCondition) {
    FilterCondition["AND"] = "and";
    FilterCondition["OR"] = "or";
    return FilterCondition;
}({});
class BaseVectorStore {
    constructor(params){
        this.embedModel = params?.embeddingModel ?? Settings.embedModel;
    }
}
const parsePrimitiveValue = (value)=>{
    if (typeof value !== "number" && typeof value !== "string") {
        throw new Error("Value must be a string or number");
    }
    return value;
};
const parseArrayValue = (value)=>{
    const isPrimitiveArray = Array.isArray(value) && value.every((v)=>typeof v === "string" || typeof v === "number");
    if (!isPrimitiveArray) {
        throw new Error("Value must be an array of strings or numbers");
    }
    return value;
};
const parseNumberValue = (value)=>{
    if (typeof value !== "number") throw new Error("Value must be a number");
    return value;
};

export { BaseVectorStore, FilterCondition, FilterOperator, VectorStoreQueryMode, escapeLikeString, metadataDictToNode, nodeToMetadata, parseArrayValue, parseNumberValue, parsePrimitiveValue, validateIsFlat };