Skip to content
Python
2.2 KB
Raw Blame
"""Bounded, ID-independent ordering of equal-score lexical search results."""
import json
import logging

logger = logging.getLogger(__name__)


def memory_content_key(item):
    """Semantic tie key for memory hits; clone UUIDs never decide order."""
    node = item.get("node")
    custom = getattr(node, "custom", None) or {}
    return (
        str(item.get("content") or getattr(node, "content", "") or ""),
        str(getattr(node, "layer", "") or item.get("layer") or ""),
        str(getattr(node, "session_id", "") or ""),
        str(getattr(node, "memory_at", "") or ""),
        json.dumps(custom.get("source_session_ids") or [], ensure_ascii=False),
        json.dumps(getattr(node, "tags", None) or [], ensure_ascii=False),
    )


def content_key(point):
    payload = point.payload or {}
    return (
        -float(point.score), str(payload.get("content") or ""),
        str(payload.get("layer") or ""), str(payload.get("session_id") or ""),
        str(payload.get("memory_at") or ""),
        json.dumps(payload.get("tags") or [], ensure_ascii=False, sort_keys=True),
    )


def bounded_keyword_ties(fetch, top_k):
    """Fetch a lookahead, expanding only when a tie crosses the cutoff.

    At most 4*k+1 points are fetched per request (three requests). If a
    larger tie still straddles the final page, omit that unresolved group:
    choosing an arbitrary subset would reintroduce ID-dependent results.
    Distinct-score ranking and every returned score remain unchanged.
    """
    if top_k <= 0:
        return []
    cap = 4 * top_k + 1
    limit = top_k + 1
    while True:
        points = list(fetch(limit))
        if len(points) < limit or len(points) <= top_k:
            return sorted(points, key=content_key)[:top_k]
        boundary = float(points[top_k - 1].score)
        if float(points[-1].score) < boundary:
            return sorted(points, key=content_key)[:top_k]
        if limit >= cap:
            logger.warning(
                "[keyword-ties] truncated tie at score=%s after %s points; "
                "returning only strictly higher scores", boundary, cap,
            )
            return sorted((p for p in points if float(p.score) > boundary), key=content_key)[:top_k]
        limit = min(2 * limit - 1, cap)