Recursive retrieval call never ends

[rahulkrprajapati]

I had defined a retriever call like given below. I have defined two separate vector store indices one for nodes and the other for leaf nodes.

class MyRetriever(AutoMergingRetriever):
    def __init__(
        self,
        node_vector_retriever: VectorIndexRetriever,
        leaf_node_vector_retriever: VectorIndexRetriever,
        storage_context: StorageContext,
        simple_ratio_thresh: float = 0.5,
        verbose: bool = False,
        callback_manager: Optional[CallbackManager] = None,
        object_map: Optional[dict] = None,
        objects: Optional[List[IndexNode]] = None,
    ) -> None:
        super().__init__(
            vector_retriever=node_vector_retriever,
            storage_context=storage_context,
            simple_ratio_thresh=simple_ratio_thresh,
            verbose=verbose,
            callback_manager=callback_manager,
            object_map=object_map,
            objects=objects,
        )
        self._leaf_node_vector_retriever = leaf_node_vector_retriever

    def _retrieve(self, query_bundle: QueryBundle) -> List[NodeWithScore]:
        initial_nodes = self._vector_retriever.retrieve(query_bundle)
        initial_leaf_nodes = self._leaf_node_vector_retriever.retrieve(query_bundle)

        # Merge the initial nodes and leaf nodes
        initial_nodes.extend(initial_leaf_nodes)

        cur_nodes, is_changed = self._try_merging(initial_nodes)
        while is_changed:
            cur_nodes, is_changed = self._try_merging(cur_nodes)

        # sort by similarity
        cur_nodes.sort(key=lambda x: x.get_score(), reverse=True)

        return cur_nodes

When I try to use it like :

my_retriever = MyRetriever(node_vector_retriever=base_retriever, leaf_node_vector_retriever=leaf_retriever, storage_context=doc_storage_context, verbose=True)

query_str = "What did the author do growing up?"
my_retrived_nodes = my_retriever._retrieve(query_str)

My Retrival line my_retrived_nodes = my_retriever._retrieve(query_str) prints :

> Merging 2 nodes into parent node.
> Parent node id: c8f15950-c3e7-4903-919e-d7f29a3c3ca2.
> Parent node text: The language we used was an early version of Fortran. You had to type programs on punch cards, th...

> Merging 4 nodes into parent node.
> Parent node id: 4e5f1308-9534-4b56-8b2a-04f496fd95ce.
> Parent node text: My nice landlady let me leave my stuff in her attic. I had some money saved from consulting work ...

but this line never finishes executing it goes into some recursive call.

[dosubot[bot]]

🤖

Hey @rahulkrprajapati, great to see you back here! Hope everything's been going well for you since our last interaction.

Based on the code you've shared, it seems like the issue might be due to the recursive nature of the _try_merging method in your MyRetriever class. This method is designed to merge nodes in different ways and it keeps trying to merge nodes until no more changes can be made. If there's a circular reference in your data, this could lead to an infinite loop.

To fix this issue, you could add a mechanism to track the nodes that have already been visited and prevent revisiting them. Here's a simple way to do this:

1. Add a visited_nodes set to the MyRetriever class to keep track of the nodes that have been visited.

class MyRetriever(AutoMergingRetriever):
    def __init__(...):
        ...
        self.visited_nodes = set()

2. In the _try_merging method, before merging a node, check if it has been visited. If it has, skip it. If it hasn't, add it to the visited_nodes set.

def _try_merging(self, nodes: List[NodeWithScore]) -> Tuple[List[NodeWithScore], bool]:
    ...
    for node in nodes:
        if node.id in self.visited_nodes:
            continue
        else:
            self.visited_nodes.add(node.id)
    ...

This way, the recursive calls will stop when they encounter a node that has already been visited, preventing infinite recursion.

Please note that this is a simple solution and might not cover all edge cases. You might need to adjust it based on your specific use case and data.

As for the _try_merging method, it's designed to merge nodes in different ways. It first attempts to fill in nodes by calling the _fill_in_nodes method. This method checks if there's a node in the middle of the current node and the next node, and if so, it adds that node to the list of new nodes. The score of the added node is set to be the average of the current node and the next node.

After filling in nodes, the _try_merging method then attempts to merge nodes by calling the _get_parents_and_merge method. This method retrieves all parent nodes and computes ratios to decide whether to merge nodes. If the ratio is high enough, it merges the nodes by deleting some child nodes and adding some parent nodes. The score of the added parent node is set to be the average of its child nodes.

The _try_merging method returns the list of merged nodes and a boolean indicating whether any changes were made during the filling in or merging process.

I hope this helps! If you have any other questions, feel free to ask.

Sources

• llama-index-core/llama_index/core/retrievers/recursive_retriever.py
• llama_index/retrievers/auto_merging_retriever.py

About Dosu

This response is meant to be useful and save you time. It is not meant to be a precise solution, but rather a starting point for your own research.

Help me be more useful! Please leave a 👍 if this is helpful and 👎 if it is irrelevant.

If you want to continue the conversation, start your reply with @dosu-bot.