索引

向量存储索引类型。

VectorStoreQueryResult dataclass

向量存储查询结果。

参数

名称	类型	描述	默认值
nodes	Sequence[BaseNode] | None		无
similarities	List[float] | None		无
ids	List[str] | None		无

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

@dataclass
class VectorStoreQueryResult:
    """Vector store query result."""

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

VectorStoreQueryMode

继承自: str, Enum

向量存储查询模式。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class VectorStoreQueryMode(str, Enum):
    """Vector store query mode."""

    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

继承自: str, Enum

向量存储过滤器运算符。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class FilterOperator(str, Enum):
    """Vector store filter operator."""

    # 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)
    TEXT_MATCH_INSENSITIVE = (
        "text_match_insensitive"  # full text match (case insensitive)
    )
    CONTAINS = "contains"  # metadata array contains value (string or number)
    IS_EMPTY = "is_empty"  # the field is not exist or empty (null or empty array)

FilterCondition

继承自: str, Enum

用于组合不同过滤器的向量存储过滤条件。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class FilterCondition(str, Enum):
    """Vector store filter conditions to combine different filters."""

    # TODO add more conditions
    AND = "and"
    OR = "or"
    NOT = "not"  # negates the filter condition

MetadataFilter

继承自: BaseModel

全面的元数据过滤器，用于向量存储以支持更多运算符。

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

参见: https://docs.pydantic.org.cn/latest/usage/types/#strict-types

参数

名称	类型	描述	默认值
key	str		必需
value	Annotated[int, Strict] | Annotated[float, Strict] | Annotated[str, Strict] | List[Annotated[str, Strict]] | List[Annotated[float, Strict]] | List[Annotated[int, Strict]] | None		必需
operator	FilterOperator		<FilterOperator.EQ: '=='>

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class MetadataFilter(BaseModel):
    r"""
    Comprehensive metadata filter for vector stores to support more operators.

    Value uses Strict* types, as int, float and str are compatible types and were all
    converted to string before.

    See: https://docs.pydantic.org.cn/latest/usage/types/#strict-types
    """

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

    @classmethod
    def from_dict(
        cls,
        filter_dict: Dict,
    ) -> "MetadataFilter":
        """
        Create MetadataFilter from dictionary.

        Args:
            filter_dict: Dict with key, value and operator.

        """
        return MetadataFilter.model_validate(filter_dict)

from_dict classmethod

from_dict(filter_dict: Dict) -> MetadataFilter

从字典创建 MetadataFilter。

参数

名称	类型	描述	默认值
filter_dict	Dict	包含 key、value 和 operator 的 Dict。	必需

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

@classmethod
def from_dict(
    cls,
    filter_dict: Dict,
) -> "MetadataFilter":
    """
    Create MetadataFilter from dictionary.

    Args:
        filter_dict: Dict with key, value and operator.

    """
    return MetadataFilter.model_validate(filter_dict)

MetadataFilters

继承自: BaseModel

向量存储的元数据过滤器。

参数

名称	类型	描述	默认值
filters	List[Union[MetadataFilter, MetadataFilters]]		必需
condition	FilterCondition | None		<FilterCondition.AND: 'and'>

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class MetadataFilters(BaseModel):
    """Metadata filters for vector stores."""

    # 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":
        """Create MetadataFilters from json."""
        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":
        """
        Create MetadataFilters from dicts.

        This takes in a list of individual MetadataFilter objects, along
        with the condition.

        Args:
            filter_dicts: List of dicts, each dict is a MetadataFilter.
            condition: FilterCondition to combine different filters.

        """
        return cls(
            filters=[
                MetadataFilter.from_dict(filter_dict) for filter_dict in filter_dicts
            ],
            condition=condition,
        )

    def legacy_filters(self) -> List[ExactMatchFilter]:
        """Convert MetadataFilters to legacy ExactMatchFilters."""
        filters = []
        for filter in self.filters:
            if (
                isinstance(filter, MetadataFilters)
                or 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。

源代码位于 llama-index-core/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":
    """Create MetadataFilters from json."""
    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] = AND) -> MetadataFilters

从字典创建 MetadataFilters。

这接收一个 MetadataFilter 对象列表以及条件。

参数

名称	类型	描述	默认值
filter_dicts	List[Dict]	字典列表，每个字典都是一个 MetadataFilter。	必需
condition	Optional[FilterCondition]	用于组合不同过滤器的 FilterCondition。	AND

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

@classmethod
def from_dicts(
    cls,
    filter_dicts: List[Dict],
    condition: Optional[FilterCondition] = FilterCondition.AND,
) -> "MetadataFilters":
    """
    Create MetadataFilters from dicts.

    This takes in a list of individual MetadataFilter objects, along
    with the condition.

    Args:
        filter_dicts: List of dicts, each dict is a MetadataFilter.
        condition: FilterCondition to combine different filters.

    """
    return cls(
        filters=[
            MetadataFilter.from_dict(filter_dict) for filter_dict in filter_dicts
        ],
        condition=condition,
    )

legacy_filters

legacy_filters() -> List[ExactMatchFilter]

将 MetadataFilters 转换为旧版 ExactMatchFilters。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

def legacy_filters(self) -> List[ExactMatchFilter]:
    """Convert MetadataFilters to legacy ExactMatchFilters."""
    filters = []
    for filter in self.filters:
        if (
            isinstance(filter, MetadataFilters)
            or 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

继承自: BaseModel

用于向量存储结构化请求的 Schema（即转换为 VectorStoreQuery）。

当前仅由 VectorIndexAutoRetriever 使用。

参数

名称	类型	描述	默认值
query	str		必需
filters	List[MetadataFilter]		必需
top_k	int | None		无

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class VectorStoreQuerySpec(BaseModel):
    """
    Schema for a structured request for vector store
    (i.e. to be converted to a VectorStoreQuery).

    Currently only used by VectorIndexAutoRetriever.
    """

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

MetadataInfo

继承自: BaseModel

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

当前仅由 VectorIndexAutoRetriever 使用。

参数

名称	类型	描述	默认值
name	str		必需
type	str		必需
description	str		必需

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class MetadataInfo(BaseModel):
    """
    Information about a metadata filter supported by a vector store.

    Currently only used by VectorIndexAutoRetriever.
    """

    name: str
    type: str
    description: str

VectorStoreInfo

继承自: BaseModel

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

当前仅由 VectorIndexAutoRetriever 使用。

参数

名称	类型	描述	默认值
metadata_info	List[MetadataInfo]		必需
content_info	str		必需

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class VectorStoreInfo(BaseModel):
    """
    Information about a vector store (content and supported metadata filters).

    Currently only used by VectorIndexAutoRetriever.
    """

    metadata_info: List[MetadataInfo]
    content_info: str

VectorStoreQuery dataclass

向量存储查询。

参数

名称	类型	描述	默认值
query_embedding	List[float] | None		无
similarity_top_k	int		1
doc_ids	List[str] | None		无
node_ids	List[str] | None		无
query_str	str | None		无
output_fields	List[str] | None		无
embedding_field	str | None		无
mode	VectorStoreQueryMode		<VectorStoreQueryMode.DEFAULT: 'default'>
alpha	float | None		无
filters	MetadataFilters | None		无
mmr_threshold	float | None		无
sparse_top_k	int | None		无
hybrid_top_k	int | None		无

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

@dataclass
class VectorStoreQuery:
    """Vector store query."""

    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

继承自: Protocol

抽象向量存储协议。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

@runtime_checkable
class VectorStore(Protocol):
    """Abstract vector store protocol."""

    stores_text: bool
    is_embedding_query: bool = True

    @property
    def client(self) -> Any:
        """Get client."""
        ...

    def add(
        self,
        nodes: List[BaseNode],
        **add_kwargs: Any,
    ) -> List[str]:
        """Add nodes with embedding to vector store."""
        ...

    async def async_add(
        self,
        nodes: List[BaseNode],
        **kwargs: Any,
    ) -> List[str]:
        """
        Asynchronously add nodes with embedding to vector store.
        NOTE: this is not implemented for all vector stores. If not implemented,
        it will just call add synchronously.
        """
        return self.add(nodes)

    def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """
        Delete nodes using with ref_doc_id."""
        ...

    async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """
        Delete nodes using with ref_doc_id.
        NOTE: this is not implemented for all vector stores. If not implemented,
        it will just call delete synchronously.
        """
        self.delete(ref_doc_id, **delete_kwargs)

    def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
        """Query vector store."""
        ...

    async def aquery(
        self, query: VectorStoreQuery, **kwargs: Any
    ) -> VectorStoreQueryResult:
        """
        Asynchronously query vector store.
        NOTE: this is not implemented for all vector stores. If not implemented,
        it will just call query synchronously.
        """
        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]

将带有嵌入的节点添加到向量存储。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

def add(
    self,
    nodes: List[BaseNode],
    **add_kwargs: Any,
) -> List[str]:
    """Add nodes with embedding to vector store."""
    ...

async_add async

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

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

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

async def async_add(
    self,
    nodes: List[BaseNode],
    **kwargs: Any,
) -> List[str]:
    """
    Asynchronously add nodes with embedding to vector store.
    NOTE: this is not implemented for all vector stores. If not implemented,
    it will just call add synchronously.
    """
    return self.add(nodes)

delete

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

使用 ref_doc_id 删除节点。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
    """
    Delete nodes using with ref_doc_id."""
    ...

adelete async

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

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

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
    """
    Delete nodes using with ref_doc_id.
    NOTE: this is not implemented for all vector stores. If not implemented,
    it will just call delete synchronously.
    """
    self.delete(ref_doc_id, **delete_kwargs)

query

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

查询向量存储。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
    """Query vector store."""
    ...

aquery async

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

异步地查询向量存储。注意：并非所有向量存储都实现了此功能。如果未实现，它将同步调用 query。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

async def aquery(
    self, query: VectorStoreQuery, **kwargs: Any
) -> VectorStoreQueryResult:
    """
    Asynchronously query vector store.
    NOTE: this is not implemented for all vector stores. If not implemented,
    it will just call query synchronously.
    """
    return self.query(query, **kwargs)

BasePydanticVectorStore

继承自: BaseComponent, ABC

抽象向量存储协议。

参数

名称	类型	描述	默认值
stores_text	bool		必需
is_embedding_query	bool		True

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

class BasePydanticVectorStore(BaseComponent, ABC):
    """Abstract vector store protocol."""

    model_config = ConfigDict(arbitrary_types_allowed=True)
    stores_text: bool
    is_embedding_query: bool = True

    @property
    @abstractmethod
    def client(self) -> Any:
        """Get client."""

    def get_nodes(
        self,
        node_ids: Optional[List[str]] = None,
        filters: Optional[MetadataFilters] = None,
    ) -> List[BaseNode]:
        """Get nodes from vector store."""
        raise NotImplementedError("get_nodes not implemented")

    async def aget_nodes(
        self,
        node_ids: Optional[List[str]] = None,
        filters: Optional[MetadataFilters] = None,
    ) -> List[BaseNode]:
        """Asynchronously get nodes from vector store."""
        return self.get_nodes(node_ids, filters)

    @abstractmethod
    def add(
        self,
        nodes: Sequence[BaseNode],
        **kwargs: Any,
    ) -> List[str]:
        """Add nodes to vector store."""

    async def async_add(
        self,
        nodes: Sequence[BaseNode],
        **kwargs: Any,
    ) -> List[str]:
        """
        Asynchronously add nodes to vector store.
        NOTE: this is not implemented for all vector stores. If not implemented,
        it will just call add synchronously.
        """
        return self.add(nodes, **kwargs)

    @abstractmethod
    def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """
        Delete nodes using with ref_doc_id."""

    async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
        """
        Delete nodes using with ref_doc_id.
        NOTE: this is not implemented for all vector stores. If not implemented,
        it will just call delete synchronously.
        """
        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:
        """Delete nodes from vector store."""
        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:
        """Asynchronously delete nodes from vector store."""
        self.delete_nodes(node_ids, filters)

    def clear(self) -> None:
        """Clear all nodes from configured vector store."""
        raise NotImplementedError("clear not implemented")

    async def aclear(self) -> None:
        """Asynchronously clear all nodes from configured vector store."""
        self.clear()

    @abstractmethod
    def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
        """Query vector store."""

    async def aquery(
        self, query: VectorStoreQuery, **kwargs: Any
    ) -> VectorStoreQueryResult:
        """
        Asynchronously query vector store.
        NOTE: this is not implemented for all vector stores. If not implemented,
        it will just call query synchronously.
        """
        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]

从向量存储获取节点。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

def get_nodes(
    self,
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
) -> List[BaseNode]:
    """Get nodes from vector store."""
    raise NotImplementedError("get_nodes not implemented")

aget_nodes async

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

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

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

async def aget_nodes(
    self,
    node_ids: Optional[List[str]] = None,
    filters: Optional[MetadataFilters] = None,
) -> List[BaseNode]:
    """Asynchronously get nodes from vector store."""
    return self.get_nodes(node_ids, filters)

add abstractmethod

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

将节点添加到向量存储。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

@abstractmethod
def add(
    self,
    nodes: Sequence[BaseNode],
    **kwargs: Any,
) -> List[str]:
    """Add nodes to vector store."""

async_add async

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

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

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

async def async_add(
    self,
    nodes: Sequence[BaseNode],
    **kwargs: Any,
) -> List[str]:
    """
    Asynchronously add nodes to vector store.
    NOTE: this is not implemented for all vector stores. If not implemented,
    it will just call add synchronously.
    """
    return self.add(nodes, **kwargs)

delete abstractmethod

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

使用 ref_doc_id 删除节点。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

@abstractmethod
def delete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
    """
    Delete nodes using with ref_doc_id."""

adelete async

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

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

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

async def adelete(self, ref_doc_id: str, **delete_kwargs: Any) -> None:
    """
    Delete nodes using with ref_doc_id.
    NOTE: this is not implemented for all vector stores. If not implemented,
    it will just call delete synchronously.
    """
    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

从向量存储删除节点。

源代码位于 llama-index-core/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:
    """Delete nodes from vector store."""
    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

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

源代码位于 llama-index-core/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:
    """Asynchronously delete nodes from vector store."""
    self.delete_nodes(node_ids, filters)

clear

clear() -> None

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

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

def clear(self) -> None:
    """Clear all nodes from configured vector store."""
    raise NotImplementedError("clear not implemented")

aclear async

aclear() -> None

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

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

async def aclear(self) -> None:
    """Asynchronously clear all nodes from configured vector store."""
    self.clear()

query abstractmethod

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

查询向量存储。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

@abstractmethod
def query(self, query: VectorStoreQuery, **kwargs: Any) -> VectorStoreQueryResult:
    """Query vector store."""

aquery async

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

异步地查询向量存储。注意：并非所有向量存储都实现了此功能。如果未实现，它将同步调用 query。

源代码位于 llama-index-core/llama_index/core/vector_stores/types.py

async def aquery(
    self, query: VectorStoreQuery, **kwargs: Any
) -> VectorStoreQueryResult:
    """
    Asynchronously query vector store.
    NOTE: this is not implemented for all vector stores. If not implemented,
    it will just call query synchronously.
    """
    return self.query(query, **kwargs)