The error you're encountering is due to nodes_with_scores being populated with tuples instead of NodeWithScore objects, which is why you're seeing an AttributeError when attempting to access a score attribute that doesn't exist on tuples. The line causing the issue is trying to sort nodes_with_scores based on the score attribute of each item, which works only if those items are NodeWithScore objects.

Your proposed solution to change key=lambda x: x.score or 0.0 to key=lambda x: x[1] will indeed avoid the AttributeError by treating each item as a tuple and sorting based on its second element. However, this approach assumes that the structure of nodes_with_scores is intended to be a list of tuples, which might not align with the original design of the code. This change could lead to incorrect behavior if the list is expected to contain objects with a score attribute.

A more appropriate solution would be to ensure that nodes_with_scores is populated with NodeWithScore objects as originally intended. This might require reviewing the upstream code that generates nodes_with_scores to correct the data type mismatch. This approach addresses the root cause of the issue and maintains the integrity of the data handling logic in the codebase.

To continue the conversation, mention @dosu.

My full solution here:

def reciprocal_rank_fusion(
results: List[List[NodeWithScore]],
) -> List[NodeWithScore]:
"""Apply reciprocal rank fusion.

The original paper uses k=60 for best results:
https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf
"""
k = 60.0  # `k` is a parameter used to control the impact of outlier rankings.
fused_scores = {}
text_to_node = {}
rank=0

for node_with_score in results:
    rank+=1
    if not isinstance(node_with_score, NodeWithScore):
        raise TypeError("node_with_score must be a NodeWithScore object.")
    text = node_with_score.node.get_content()
    text_to_node[text] = node_with_score
    if text not in fused_scores:
      fused_scores[text] = 0.0
    fused_scores[text] += 1.0 / (rank + k)
    #print(fused_scores) / (rank + k)

# sort results
reranked_results = dict(
    sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)
)

# adjust node scores
reranked_nodes: List[NodeWithScore] = []
for text, score in reranked_results.items():
    reranked_nodes.append(text_to_node[text])
    reranked_nodes[-1].score = score
#print(reranked_nodes)
return reranked_nodes