Index

向量存储索引类型。

VectorStoreQueryResult dataclass

存储查询结果的向量。

Source code in llama_index/core/vector_stores/types.py

@dataclass
class VectorStoreQueryResult:
    """存储查询结果的向量。"""

    nodes: Optional[Sequence[BaseNode]] = None
    similarities: Optional[List[float]] = None
    ids: Optional[List[str]] = None

VectorStoreQueryMode

Bases: str, Enum

向量存储查询模式。

Source code in llama_index/core/vector_stores/types.py

class VectorStoreQueryMode(str, Enum):
    """向量存储查询模式。"""

    DEFAULT = "default"
    SPARSE = "sparse"
    HYBRID = "hybrid"
    TEXT_SEARCH = "text_search"
    SEMANTIC_HYBRID = "semantic_hybrid"

    # fit learners
    SVM = "svm"
    LOGISTIC_REGRESSION = "logistic_regression"
    LINEAR_REGRESSION = "linear_regression"

    # maximum marginal relevance
    MMR = "mmr"

FilterOperator

Bases: str, Enum

向量存储过滤器操作符。

Source code in llama_index/core/vector_stores/types.py

class FilterOperator(str, Enum):
    """向量存储过滤器操作符。"""

    # TODO add more operators
    EQ = "=="  # default operator (string, int, float)
    GT = ">"  # greater than (int, float)
    LT = "<"  # less than (int, float)
    NE = "!="  # not equal to (string, int, float)
    GTE = ">="  # greater than or equal to (int, float)
    LTE = "<="  # less than or equal to (int, float)
    IN = "in"  # In array (string or number)
    NIN = "nin"  # Not in array (string or number)
    ANY = "any"  # Contains any (array of strings)
    ALL = "all"  # Contains all (array of strings)
    TEXT_MATCH = "text_match"  # full text match (allows you to search for a specific substring, token or phrase within the text field)
    CONTAINS = "contains"  # metadata array contains value (string or number)

FilterCondition

Bases: str, Enum

向量存储过滤条件，以组合不同的过滤器。

Source code in llama_index/core/vector_stores/types.py

class FilterCondition(str, Enum):
    """向量存储过滤条件，以组合不同的过滤器。"""

    # TODO add more conditions
    AND = "and"
    OR = "or"

MetadataFilter

Bases: BaseModel

全面的元数据过滤器，用于支持更多的操作符。

值使用Strict*类型，因为int、float和str是兼容的类型，而且在转换之前都被转换为字符串。

参见：https://docs.pydantic.dev/latest/usage/types/#strict-types

Source code in llama_index/core/vector_stores/types.py

class MetadataFilter(BaseModel):
    """全面的元数据过滤器，用于支持更多的操作符。

值使用Strict*类型，因为int、float和str是兼容的类型，而且在转换之前都被转换为字符串。

参见：https://docs.pydantic.dev/latest/usage/types/#strict-types"""

    key: str
    value: Union[StrictInt, StrictFloat, StrictStr, List[StrictStr]]
    operator: FilterOperator = FilterOperator.EQ

    @classmethod
    def from_dict(
        cls,
        filter_dict: Dict,
    ) -> "MetadataFilter":
        """创建一个基于字典的MetadataFilter。

Args:
    filter_dict: 包含键、值和操作符的字典。
"""
        return MetadataFilter.parse_obj(filter_dict)

from_dict classmethod

from_dict(filter_dict: Dict) -> MetadataFilter

创建一个基于字典的MetadataFilter。

Parameters:

Name	Type	Description	Default
filter_dict	Dict	包含键、值和操作符的字典。	required

Source code in llama_index/core/vector_stores/types.py

    @classmethod
    def from_dict(
        cls,
        filter_dict: Dict,
    ) -> "MetadataFilter":
        """创建一个基于字典的MetadataFilter。

Args:
    filter_dict: 包含键、值和操作符的字典。
"""
        return MetadataFilter.parse_obj(filter_dict)

MetadataFilters

Bases: BaseModel

元数据过滤器用于向量存储。

Source code in llama_index/core/vector_stores/types.py

class MetadataFilters(BaseModel):
    """元数据过滤器用于向量存储。"""

    # Exact match filters and Advanced filters with operators like >, <, >=, <=, !=, etc.
    filters: List[Union[MetadataFilter, ExactMatchFilter, "MetadataFilters"]]
    # and/or such conditions for combining different filters
    condition: Optional[FilterCondition] = FilterCondition.AND

    @classmethod
    @deprecated(
        "`from_dict()` is deprecated. "
        "Please use `MetadataFilters(filters=.., condition='and')` directly instead."
    )
    def from_dict(cls, filter_dict: Dict) -> "MetadataFilters":
        """从json中创建MetadataFilters。"""
        filters = []
        for k, v in filter_dict.items():
            filter = MetadataFilter(key=k, value=v, operator=FilterOperator.EQ)
            filters.append(filter)
        return cls(filters=filters)

    @classmethod
    def from_dicts(
        cls,
        filter_dicts: List[Dict],
        condition: Optional[FilterCondition] = FilterCondition.AND,
    ) -> "MetadataFilters":
        """从字典中创建MetadataFilters。

这个函数接受一个单独的MetadataFilter对象列表，以及条件。

Args:
    filter_dicts: 字典列表，每个字典都是一个MetadataFilter。
    condition: FilterCondition，用于组合不同的过滤器。
"""
        return cls(
            filters=[
                MetadataFilter.from_dict(filter_dict) for filter_dict in filter_dicts
            ],
            condition=condition,
        )

    def legacy_filters(self) -> List[ExactMatchFilter]:
        """将MetadataFilters转换为传统的ExactMatchFilters。"""
        filters = []
        for filter in self.filters:
            if filter.operator != FilterOperator.EQ:
                raise ValueError(
                    "Vector Store only supports exact match filters. "
                    "Please use ExactMatchFilter or FilterOperator.EQ instead."
                )
            filters.append(ExactMatchFilter(key=filter.key, value=filter.value))
        return filters

from_dict classmethod

from_dict(filter_dict: Dict) -> MetadataFilters

从json中创建MetadataFilters。

Source code in llama_index/core/vector_stores/types.py

@classmethod
@deprecated(
    "`from_dict()` is deprecated. "
    "Please use `MetadataFilters(filters=.., condition='and')` directly instead."
)
def from_dict(cls, filter_dict: Dict) -> "MetadataFilters":
    """从json中创建MetadataFilters。"""
    filters = []
    for k, v in filter_dict.items():
        filter = MetadataFilter(key=k, value=v, operator=FilterOperator.EQ)
        filters.append(filter)
    return cls(filters=filters)

from_dicts classmethod

from_dicts(
    filter_dicts: List[Dict],
    condition: Optional[
        FilterCondition
    ] = FilterCondition.AND,
) -> MetadataFilters

从字典中创建MetadataFilters。

这个函数接受一个单独的MetadataFilter对象列表，以及条件。

Parameters:

Name	Type	Description	Default
filter_dicts	List[Dict]	字典列表，每个字典都是一个MetadataFilter。	required
condition	Optional[FilterCondition]	FilterCondition，用于组合不同的过滤器。	AND

Source code in llama_index/core/vector_stores/types.py

    @classmethod
    def from_dicts(
        cls,
        filter_dicts: List[Dict],
        condition: Optional[FilterCondition] = FilterCondition.AND,
    ) -> "MetadataFilters":
        """从字典中创建MetadataFilters。

这个函数接受一个单独的MetadataFilter对象列表，以及条件。

Args:
    filter_dicts: 字典列表，每个字典都是一个MetadataFilter。
    condition: FilterCondition，用于组合不同的过滤器。
"""
        return cls(
            filters=[
                MetadataFilter.from_dict(filter_dict) for filter_dict in filter_dicts
            ],
            condition=condition,
        )

legacy_filters

legacy_filters() -> List[ExactMatchFilter]

将MetadataFilters转换为传统的ExactMatchFilters。

Source code in llama_index/core/vector_stores/types.py

def legacy_filters(self) -> List[ExactMatchFilter]:
    """将MetadataFilters转换为传统的ExactMatchFilters。"""
    filters = []
    for filter in self.filters:
        if filter.operator != FilterOperator.EQ:
            raise ValueError(
                "Vector Store only supports exact match filters. "
                "Please use ExactMatchFilter or FilterOperator.EQ instead."
            )
        filters.append(ExactMatchFilter(key=filter.key, value=filter.value))
    return filters

VectorStoreQuerySpec

Bases: BaseModel

结构化请求向量存储的模式 （即将被转换为VectorStoreQuery）。

目前仅被VectorIndexAutoRetriever使用。

Source code in llama_index/core/vector_stores/types.py

class VectorStoreQuerySpec(BaseModel):
    """结构化请求向量存储的模式
（即将被转换为VectorStoreQuery）。

目前仅被VectorIndexAutoRetriever使用。"""

    query: str
    filters: List[MetadataFilter]
    top_k: Optional[int] = None

MetadataInfo

Bases: BaseModel

关于向量存储支持的元数据过滤器的信息。

目前仅由VectorIndexAutoRetriever使用。

Source code in llama_index/core/vector_stores/types.py

class MetadataInfo(BaseModel):
    """关于向量存储支持的元数据过滤器的信息。

目前仅由VectorIndexAutoRetriever使用。"""

    name: str
    type: str
    description: str

VectorStoreInfo

Bases: BaseModel

关于向量存储的信息（内容和支持的元数据过滤器）。

目前仅被VectorIndexAutoRetriever使用。

Source code in llama_index/core/vector_stores/types.py

class VectorStoreInfo(BaseModel):
    """关于向量存储的信息（内容和支持的元数据过滤器）。

目前仅被VectorIndexAutoRetriever使用。"""

    metadata_info: List[MetadataInfo]
    content_info: str

VectorStoreQuery dataclass

向量存储查询。

Source code in llama_index/core/vector_stores/types.py

@dataclass
class VectorStoreQuery:
    """向量存储查询。"""

    query_embedding: Optional[List[float]] = None
    similarity_top_k: int = 1
    doc_ids: Optional[List[str]] = None
    node_ids: Optional[List[str]] = None
    query_str: Optional[str] = None
    output_fields: Optional[List[str]] = None
    embedding_field: Optional[str] = None

    mode: VectorStoreQueryMode = VectorStoreQueryMode.DEFAULT

    # NOTE: only for hybrid search (0 for bm25, 1 for vector search)
    alpha: Optional[float] = None

    # metadata filters
    filters: Optional[MetadataFilters] = None

    # only for mmr
    mmr_threshold: Optional[float] = None

    # NOTE: currently only used by postgres hybrid search
    sparse_top_k: Optional[int] = None
    # NOTE: return top k results from hybrid search. similarity_top_k is used for dense search top k
    hybrid_top_k: Optional[int] = None

VectorStore

Bases: Protocol

抽象向量存储协议。

Source code in llama_index/core/vector_stores/types.py

@runtime_checkable
class VectorStore(Protocol):
    """抽象向量存储协议。"""

    stores_text: bool
    is_embedding_query: bool = True

    @property
    def client(self) -> Any:
        """获取客户端。"""
        ...

    def add(
        self,
        nodes: List[BaseNode],
        **add_kwargs: Any,
    ) -> List[str]:
        """向向量存储中添加带嵌入的节点。"""
        ...

    async def async_add(
        self,
        nodes: List[BaseNode],
        **kwargs: Any,
    ) -> List[str]:
        """异步将带有嵌入的节点添加到向量存储中。
注意：并非所有向量存储都实现了此功能。如果未实现，它将会同步调用添加操作。
"""
        return self.add(nodes)

    def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """
        使用ref_doc_id删除节点。"""
        ...

    async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """使用ref_doc_id删除节点。
注意：并非所有向量存储都实现了此功能。如果未实现，它将仅同步调用删除。
"""
        self.delete(ref_doc_id, **delete_kwargs)

    def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
        """查询向量存储。"""
        ...

    async def aquery(
        self, query: VectorStoreQuery, **kwargs: Any
    ) -> VectorStoreQueryResult:
        """异步查询向量存储。
注意：并非所有向量存储都实现了这个功能。如果没有实现，它将会同步调用查询。
"""
        return self.query(query, **kwargs)

    def persist(
        self, persist_path: str, fs: Optional[fsspec.AbstractFileSystem] = None
    ) -> None:
        return None

client property

client: Any

获取客户端。

add

add(nodes: List[BaseNode], **add_kwargs: Any) -> List[str]

向向量存储中添加带嵌入的节点。

Source code in llama_index/core/vector_stores/types.py

def add(
    self,
    nodes: List[BaseNode],
    **add_kwargs: Any,
) -> List[str]:
    """向向量存储中添加带嵌入的节点。"""
    ...

async_add async

async_add(
    nodes: List[BaseNode], **kwargs: Any
) -> List[str]

异步将带有嵌入的节点添加到向量存储中。 注意：并非所有向量存储都实现了此功能。如果未实现，它将会同步调用添加操作。

Source code in llama_index/core/vector_stores/types.py

    async def async_add(
        self,
        nodes: List[BaseNode],
        **kwargs: Any,
    ) -> List[str]:
        """异步将带有嵌入的节点添加到向量存储中。
注意：并非所有向量存储都实现了此功能。如果未实现，它将会同步调用添加操作。
"""
        return self.add(nodes)

delete

delete(ref_doc_id: str, **delete_kwargs: Any) -> None

使用ref_doc_id删除节点。

Source code in llama_index/core/vector_stores/types.py

def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
    """
    使用ref_doc_id删除节点。"""
    ...

adelete async

adelete(ref_doc_id: str, **delete_kwargs: Any) -> None

使用ref_doc_id删除节点。 注意：并非所有向量存储都实现了此功能。如果未实现，它将仅同步调用删除。

Source code in llama_index/core/vector_stores/types.py

    async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """使用ref_doc_id删除节点。
注意：并非所有向量存储都实现了此功能。如果未实现，它将仅同步调用删除。
"""
        self.delete(ref_doc_id, **delete_kwargs)

query

query(
    query: VectorStoreQuery, **kwargs: Any
) -> VectorStoreQueryResult

查询向量存储。

Source code in llama_index/core/vector_stores/types.py

def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
    """查询向量存储。"""
    ...

aquery async

aquery(
    query: VectorStoreQuery, **kwargs: Any
) -> VectorStoreQueryResult

异步查询向量存储。 注意：并非所有向量存储都实现了这个功能。如果没有实现，它将会同步调用查询。

Source code in llama_index/core/vector_stores/types.py

    async def aquery(
        self, query: VectorStoreQuery, **kwargs: Any
    ) -> VectorStoreQueryResult:
        """异步查询向量存储。
注意：并非所有向量存储都实现了这个功能。如果没有实现，它将会同步调用查询。
"""
        return self.query(query, **kwargs)

BasePydanticVectorStore

Bases: BaseComponent, ABC

抽象向量存储协议。

Source code in llama_index/core/vector_stores/types.py

class BasePydanticVectorStore(BaseComponent, ABC):
    """抽象向量存储协议。"""

    stores_text: bool
    is_embedding_query: bool = True

    class Config:
        arbitrary_types_allowed = True

    @property
    @abstractmethod
    def client(self) -> Any:
        """获取客户端。"""

    def get_nodes(
        self,
        node_ids: Optional[List[str]] = None,
        filters: Optional[MetadataFilters] = None,
    ) -> List[BaseNode]:
        """从向量存储中获取节点。"""
        raise NotImplementedError("get_nodes not implemented")

    async def aget_nodes(
        self,
        node_ids: Optional[List[str]] = None,
        filters: Optional[MetadataFilters] = None,
    ) -> List[BaseNode]:
        """从向量存储异步获取节点。"""
        return self.get_nodes(node_ids, filters)

    @abstractmethod
    def add(
        self,
        nodes: List[BaseNode],
    ) -> List[str]:
        """向向量存储中添加节点。"""

    async def async_add(
        self,
        nodes: List[BaseNode],
        **kwargs: Any,
    ) -> List[str]:
        """异步将节点添加到向量存储中。
注意：并非所有向量存储都实现了此功能。如果未实现，它将会同步调用添加操作。
"""
        return self.add(nodes)

    @abstractmethod
    def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """
        使用ref_doc_id删除节点。"""

    async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """使用ref_doc_id删除节点。
注意：并非所有向量存储都实现了此功能。如果未实现，它将仅同步调用删除。
"""
        self.delete(ref_doc_id, **delete_kwargs)

    def delete_nodes(
        self,
        node_ids: Optional[List[str]] = None,
        filters: Optional[MetadataFilters] = None,
        **delete_kwargs: Any,
    ) -> None:
        """从向量存储中删除节点。"""
        raise NotImplementedError("delete_nodes not implemented")

    async def adelete_nodes(
        self,
        node_ids: Optional[List[str]] = None,
        filters: Optional[MetadataFilters] = None,
        **delete_kwargs: Any,
    ) -> None:
        """异步从向量存储中删除节点。"""
        self.delete_nodes(node_ids, filters)

    def clear(self) -> None:
        """清除配置的向量存储中的所有节点。"""
        raise NotImplementedError("clear not implemented")

    async def aclear(self) -> None:
        """异步清除配置的向量存储中的所有节点。"""
        self.clear()

    @abstractmethod
    def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
        """查询向量存储。"""

    async def aquery(
        self, query: VectorStoreQuery, **kwargs: Any
    ) -> VectorStoreQueryResult:
        """异步查询向量存储。
注意：并非所有向量存储都实现了这个功能。如果没有实现，它将会同步调用查询。
"""
        return self.query(query, **kwargs)

    def persist(
        self, persist_path: str, fs: Optional[fsspec.AbstractFileSystem] = None
    ) -> None:
        return None

client abstractmethod property

client: Any

获取客户端。

get_nodes

get_nodes(
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
) -> List[BaseNode]

从向量存储中获取节点。

Source code in llama_index/core/vector_stores/types.py

def get_nodes(
    self,
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
) -> List[BaseNode]:
    """从向量存储中获取节点。"""
    raise NotImplementedError("get_nodes not implemented")

aget_nodes async

aget_nodes(
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
) -> List[BaseNode]

从向量存储异步获取节点。

Source code in llama_index/core/vector_stores/types.py

async def aget_nodes(
    self,
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
) -> List[BaseNode]:
    """从向量存储异步获取节点。"""
    return self.get_nodes(node_ids, filters)

add abstractmethod

add(nodes: List[BaseNode]) -> List[str]

向向量存储中添加节点。

Source code in llama_index/core/vector_stores/types.py

@abstractmethod
def add(
    self,
    nodes: List[BaseNode],
) -> List[str]:
    """向向量存储中添加节点。"""

async_add async

async_add(
    nodes: List[BaseNode], **kwargs: Any
) -> List[str]

异步将节点添加到向量存储中。 注意：并非所有向量存储都实现了此功能。如果未实现，它将会同步调用添加操作。

Source code in llama_index/core/vector_stores/types.py

    async def async_add(
        self,
        nodes: List[BaseNode],
        **kwargs: Any,
    ) -> List[str]:
        """异步将节点添加到向量存储中。
注意：并非所有向量存储都实现了此功能。如果未实现，它将会同步调用添加操作。
"""
        return self.add(nodes)

delete abstractmethod

delete(ref_doc_id: str, **delete_kwargs: Any) -> None

使用ref_doc_id删除节点。

Source code in llama_index/core/vector_stores/types.py

@abstractmethod
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
    """
    使用ref_doc_id删除节点。"""

adelete async

adelete(ref_doc_id: str, **delete_kwargs: Any) -> None

使用ref_doc_id删除节点。 注意：并非所有向量存储都实现了此功能。如果未实现，它将仅同步调用删除。

Source code in llama_index/core/vector_stores/types.py

    async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """使用ref_doc_id删除节点。
注意：并非所有向量存储都实现了此功能。如果未实现，它将仅同步调用删除。
"""
        self.delete(ref_doc_id, **delete_kwargs)

delete_nodes

delete_nodes(
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
    **delete_kwargs: Any
) -> None

从向量存储中删除节点。

Source code in llama_index/core/vector_stores/types.py

def delete_nodes(
    self,
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
    **delete_kwargs: Any,
) -> None:
    """从向量存储中删除节点。"""
    raise NotImplementedError("delete_nodes not implemented")

adelete_nodes async

adelete_nodes(
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
    **delete_kwargs: Any
) -> None

异步从向量存储中删除节点。

Source code in llama_index/core/vector_stores/types.py

async def adelete_nodes(
    self,
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
    **delete_kwargs: Any,
) -> None:
    """异步从向量存储中删除节点。"""
    self.delete_nodes(node_ids, filters)

clear

clear() -> None

清除配置的向量存储中的所有节点。

Source code in llama_index/core/vector_stores/types.py

def clear(self) -> None:
    """清除配置的向量存储中的所有节点。"""
    raise NotImplementedError("clear not implemented")

aclear async

aclear() -> None

异步清除配置的向量存储中的所有节点。

Source code in llama_index/core/vector_stores/types.py

async def aclear(self) -> None:
    """异步清除配置的向量存储中的所有节点。"""
    self.clear()

query abstractmethod

query(
    query: VectorStoreQuery, **kwargs: Any
) -> VectorStoreQueryResult

查询向量存储。

Source code in llama_index/core/vector_stores/types.py

@abstractmethod
def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
    """查询向量存储。"""

aquery async

aquery(
    query: VectorStoreQuery, **kwargs: Any
) -> VectorStoreQueryResult

异步查询向量存储。 注意：并非所有向量存储都实现了这个功能。如果没有实现，它将会同步调用查询。

Source code in llama_index/core/vector_stores/types.py

    async def aquery(
        self, query: VectorStoreQuery, **kwargs: Any
    ) -> VectorStoreQueryResult:
        """异步查询向量存储。
注意：并非所有向量存储都实现了这个功能。如果没有实现，它将会同步调用查询。
"""
        return self.query(query, **kwargs)