Retriever

RetrieverQueryEngine

Bases: BaseQueryEngine

检索器查询引擎。

Parameters:

Name	Type	Description	Default
retriever	BaseRetriever	一个检索器对象。	required
response_synthesizer	Optional[BaseSynthesizer]	一个BaseSynthesizer对象。	None
callback_manager	Optional[CallbackManager]	一个回调管理器。	None

Source code in llama_index/core/query_engine/retriever_query_engine.py

class RetrieverQueryEngine(BaseQueryEngine):
    """检索器查询引擎。

    Args:
        retriever (BaseRetriever): 一个检索器对象。
        response_synthesizer (Optional[BaseSynthesizer]): 一个BaseSynthesizer对象。
        callback_manager (Optional[CallbackManager]): 一个回调管理器。"""

    def __init__(
        self,
        retriever: BaseRetriever,
        response_synthesizer: Optional[BaseSynthesizer] = None,
        node_postprocessors: Optional[List[BaseNodePostprocessor]] = None,
        callback_manager: Optional[CallbackManager] = None,
    ) -> None:
        self._retriever = retriever
        self._response_synthesizer = response_synthesizer or get_response_synthesizer(
            llm=llm_from_settings_or_context(Settings, retriever.get_service_context()),
            callback_manager=callback_manager
            or callback_manager_from_settings_or_context(
                Settings, retriever.get_service_context()
            ),
        )

        self._node_postprocessors = node_postprocessors or []
        callback_manager = (
            callback_manager or self._response_synthesizer.callback_manager
        )
        for node_postprocessor in self._node_postprocessors:
            node_postprocessor.callback_manager = callback_manager
        super().__init__(callback_manager=callback_manager)

    def _get_prompt_modules(self) -> PromptMixinType:
        """获取提示子模块。"""
        return {"response_synthesizer": self._response_synthesizer}

    @classmethod
    def from_args(
        cls,
        retriever: BaseRetriever,
        llm: Optional[LLM] = None,
        response_synthesizer: Optional[BaseSynthesizer] = None,
        node_postprocessors: Optional[List[BaseNodePostprocessor]] = None,
        # response synthesizer args
        response_mode: ResponseMode = ResponseMode.COMPACT,
        text_qa_template: Optional[BasePromptTemplate] = None,
        refine_template: Optional[BasePromptTemplate] = None,
        summary_template: Optional[BasePromptTemplate] = None,
        simple_template: Optional[BasePromptTemplate] = None,
        output_cls: Optional[BaseModel] = None,
        use_async: bool = False,
        streaming: bool = False,
        # deprecated
        service_context: Optional[ServiceContext] = None,
        **kwargs: Any,
    ) -> "RetrieverQueryEngine":
        """初始化一个RetrieverQueryEngine对象。

Args:
    retriever (BaseRetriever): 一个检索器对象。
    service_context (Optional[ServiceContext]): 一个ServiceContext对象。
    node_postprocessors (Optional[List[BaseNodePostprocessor]]): 一个节点后处理器列表。
    verbose (bool): 是否打印调试信息。
    response_mode (ResponseMode): 一个ResponseMode对象。
    text_qa_template (Optional[BasePromptTemplate]): 一个BasePromptTemplate对象。
    refine_template (Optional[BasePromptTemplate]): 一个BasePromptTemplate对象。
    simple_template (Optional[BasePromptTemplate]): 一个BasePromptTemplate对象。
    use_async (bool): 是否使用异步。
    streaming (bool): 是否使用流式处理。
    optimizer (Optional[BaseTokenUsageOptimizer]): 一个BaseTokenUsageOptimizer对象。
"""
        llm = llm or llm_from_settings_or_context(Settings, service_context)

        response_synthesizer = response_synthesizer or get_response_synthesizer(
            llm=llm,
            service_context=service_context,
            text_qa_template=text_qa_template,
            refine_template=refine_template,
            summary_template=summary_template,
            simple_template=simple_template,
            response_mode=response_mode,
            output_cls=output_cls,
            use_async=use_async,
            streaming=streaming,
        )

        callback_manager = callback_manager_from_settings_or_context(
            Settings, service_context
        )

        return cls(
            retriever=retriever,
            response_synthesizer=response_synthesizer,
            callback_manager=callback_manager,
            node_postprocessors=node_postprocessors,
        )

    def _apply_node_postprocessors(
        self, nodes: List[NodeWithScore], query_bundle: QueryBundle
    ) -> List[NodeWithScore]:
        for node_postprocessor in self._node_postprocessors:
            nodes = node_postprocessor.postprocess_nodes(
                nodes, query_bundle=query_bundle
            )
        return nodes

    def retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]:
        nodes = self._retriever.retrieve(query_bundle)
        return self._apply_node_postprocessors(nodes, query_bundle=query_bundle)

    async def aretrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]:
        nodes = await self._retriever.aretrieve(query_bundle)
        return self._apply_node_postprocessors(nodes, query_bundle=query_bundle)

    def with_retriever(self, retriever: BaseRetriever) -> "RetrieverQueryEngine":
        return RetrieverQueryEngine(
            retriever=retriever,
            response_synthesizer=self._response_synthesizer,
            callback_manager=self.callback_manager,
            node_postprocessors=self._node_postprocessors,
        )

    def synthesize(
        self,
        query_bundle: QueryBundle,
        nodes: List[NodeWithScore],
        additional_source_nodes: Optional[Sequence[NodeWithScore]] = None,
    ) -> RESPONSE_TYPE:
        return self._response_synthesizer.synthesize(
            query=query_bundle,
            nodes=nodes,
            additional_source_nodes=additional_source_nodes,
        )

    async def asynthesize(
        self,
        query_bundle: QueryBundle,
        nodes: List[NodeWithScore],
        additional_source_nodes: Optional[Sequence[NodeWithScore]] = None,
    ) -> RESPONSE_TYPE:
        return await self._response_synthesizer.asynthesize(
            query=query_bundle,
            nodes=nodes,
            additional_source_nodes=additional_source_nodes,
        )

    @dispatcher.span
    def _query(self, query_bundle: QueryBundle) -> RESPONSE_TYPE:
        """回答一个查询。"""
        with self.callback_manager.event(
            CBEventType.QUERY, payload={EventPayload.QUERY_STR: query_bundle.query_str}
        ) as query_event:
            nodes = self.retrieve(query_bundle)
            response = self._response_synthesizer.synthesize(
                query=query_bundle,
                nodes=nodes,
            )
            query_event.on_end(payload={EventPayload.RESPONSE: response})

        return response

    @dispatcher.span
    async def _aquery(self, query_bundle: QueryBundle) -> RESPONSE_TYPE:
        """回答一个查询。"""
        with self.callback_manager.event(
            CBEventType.QUERY, payload={EventPayload.QUERY_STR: query_bundle.query_str}
        ) as query_event:
            nodes = await self.aretrieve(query_bundle)

            response = await self._response_synthesizer.asynthesize(
                query=query_bundle,
                nodes=nodes,
            )

            query_event.on_end(payload={EventPayload.RESPONSE: response})

        return response

    @property
    def retriever(self) -> BaseRetriever:
        """获取检索器对象。"""
        return self._retriever

retriever property

retriever: BaseRetriever

获取检索器对象。

from_args classmethod

from_args(
    retriever: BaseRetriever,
    llm: Optional[LLM] = None,
    response_synthesizer: Optional[BaseSynthesizer] = None,
    node_postprocessors: Optional[
        List[BaseNodePostprocessor]
    ] = None,
    response_mode: ResponseMode = ResponseMode.COMPACT,
    text_qa_template: Optional[BasePromptTemplate] = None,
    refine_template: Optional[BasePromptTemplate] = None,
    summary_template: Optional[BasePromptTemplate] = None,
    simple_template: Optional[BasePromptTemplate] = None,
    output_cls: Optional[BaseModel] = None,
    use_async: bool = False,
    streaming: bool = False,
    service_context: Optional[ServiceContext] = None,
    **kwargs: Any
) -> RetrieverQueryEngine

初始化一个RetrieverQueryEngine对象。

Parameters:

Name	Type	Description	Default
retriever	BaseRetriever	一个检索器对象。	required
service_context	Optional[ServiceContext]	一个ServiceContext对象。	None
node_postprocessors	Optional[List[BaseNodePostprocessor]]	一个节点后处理器列表。	None
verbose	bool	是否打印调试信息。	required
response_mode	ResponseMode	一个ResponseMode对象。	COMPACT
text_qa_template	Optional[BasePromptTemplate]	一个BasePromptTemplate对象。	None
refine_template	Optional[BasePromptTemplate]	一个BasePromptTemplate对象。	None
simple_template	Optional[BasePromptTemplate]	一个BasePromptTemplate对象。	None
use_async	bool	是否使用异步。	False
streaming	bool	是否使用流式处理。	False
optimizer	Optional[BaseTokenUsageOptimizer]	一个BaseTokenUsageOptimizer对象。	required

Source code in llama_index/core/query_engine/retriever_query_engine.py

    @classmethod
    def from_args(
        cls,
        retriever: BaseRetriever,
        llm: Optional[LLM] = None,
        response_synthesizer: Optional[BaseSynthesizer] = None,
        node_postprocessors: Optional[List[BaseNodePostprocessor]] = None,
        # response synthesizer args
        response_mode: ResponseMode = ResponseMode.COMPACT,
        text_qa_template: Optional[BasePromptTemplate] = None,
        refine_template: Optional[BasePromptTemplate] = None,
        summary_template: Optional[BasePromptTemplate] = None,
        simple_template: Optional[BasePromptTemplate] = None,
        output_cls: Optional[BaseModel] = None,
        use_async: bool = False,
        streaming: bool = False,
        # deprecated
        service_context: Optional[ServiceContext] = None,
        **kwargs: Any,
    ) -> "RetrieverQueryEngine":
        """初始化一个RetrieverQueryEngine对象。

Args:
    retriever (BaseRetriever): 一个检索器对象。
    service_context (Optional[ServiceContext]): 一个ServiceContext对象。
    node_postprocessors (Optional[List[BaseNodePostprocessor]]): 一个节点后处理器列表。
    verbose (bool): 是否打印调试信息。
    response_mode (ResponseMode): 一个ResponseMode对象。
    text_qa_template (Optional[BasePromptTemplate]): 一个BasePromptTemplate对象。
    refine_template (Optional[BasePromptTemplate]): 一个BasePromptTemplate对象。
    simple_template (Optional[BasePromptTemplate]): 一个BasePromptTemplate对象。
    use_async (bool): 是否使用异步。
    streaming (bool): 是否使用流式处理。
    optimizer (Optional[BaseTokenUsageOptimizer]): 一个BaseTokenUsageOptimizer对象。
"""
        llm = llm or llm_from_settings_or_context(Settings, service_context)

        response_synthesizer = response_synthesizer or get_response_synthesizer(
            llm=llm,
            service_context=service_context,
            text_qa_template=text_qa_template,
            refine_template=refine_template,
            summary_template=summary_template,
            simple_template=simple_template,
            response_mode=response_mode,
            output_cls=output_cls,
            use_async=use_async,
            streaming=streaming,
        )

        callback_manager = callback_manager_from_settings_or_context(
            Settings, service_context
        )

        return cls(
            retriever=retriever,
            response_synthesizer=response_synthesizer,
            callback_manager=callback_manager,
            node_postprocessors=node_postprocessors,
        )