claude-code-workflow 6.3.53 → 7.0.0

package/codex-lens/src/codexlens/search/clustering/hdbscan_strategy.py

@@ -79,11 +79,33 @@ class HDBSCANStrategy(BaseClusteringStrategy):
             # Return each result as its own singleton cluster
             return [[i] for i in range(n_results)]
 
+        metric = self.config.metric
+        data = embeddings
+
+        # Some hdbscan builds do not recognize metric="cosine" even though it's a
+        # common need for embedding clustering. In that case, compute a precomputed
+        # cosine distance matrix and run HDBSCAN with metric="precomputed".
+        if metric == "cosine":
+            try:
+                from sklearn.metrics import pairwise_distances
+
+                data = pairwise_distances(embeddings, metric="cosine")
+                # Some hdbscan builds are strict about dtype for precomputed distances.
+                # Ensure float64 to avoid Buffer dtype mismatch errors.
+                try:
+                    data = data.astype("float64", copy=False)
+                except Exception:
+                    pass
+                metric = "precomputed"
+            except Exception:
+                # If we cannot compute distances, fall back to euclidean over raw vectors.
+                metric = "euclidean"
+
         # Configure HDBSCAN clusterer
         clusterer = hdbscan.HDBSCAN(
             min_cluster_size=self.config.min_cluster_size,
             min_samples=self.config.min_samples,
-            metric=self.config.metric,
+            metric=metric,
             cluster_selection_epsilon=self.config.cluster_selection_epsilon,
             allow_single_cluster=self.config.allow_single_cluster,
             prediction_data=self.config.prediction_data,
@@ -91,7 +113,7 @@ class HDBSCANStrategy(BaseClusteringStrategy):
 
         # Fit and get cluster labels
         # Labels: -1 = noise, 0+ = cluster index
-        labels = clusterer.fit_predict(embeddings)
+        labels = clusterer.fit_predict(data)
 
         # Group indices by cluster label
         cluster_map: dict[int, list[int]] = {}

package/codex-lens/src/codexlens/search/global_graph_expander.py

@@ -0,0 +1,250 @@
+"""Global graph expansion for search results using cross-directory relationships.
+
+Expands top search results with related symbols by querying the global_relationships
+table in GlobalSymbolIndex, enabling project-wide code graph traversal.
+"""
+
+from __future__ import annotations
+
+import logging
+import sqlite3
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from codexlens.config import Config
+from codexlens.entities import SearchResult
+from codexlens.storage.global_index import GlobalSymbolIndex
+
+logger = logging.getLogger(__name__)
+
+# Score decay factors by relationship type.
+# INHERITS has highest factor (strongest semantic link),
+# IMPORTS next (explicit dependency), CALLS lowest (may be indirect).
+DECAY_FACTORS: Dict[str, float] = {
+    "imports": 0.4,
+    "inherits": 0.5,
+    "calls": 0.3,
+}
+DEFAULT_DECAY = 0.3
+
+
+class GlobalGraphExpander:
+    """Expands search results with cross-directory related symbols from the global graph."""
+
+    def __init__(
+        self,
+        global_index: GlobalSymbolIndex,
+        *,
+        config: Optional[Config] = None,
+    ) -> None:
+        self._global_index = global_index
+        self._config = config
+        self._logger = logging.getLogger(__name__)
+
+    def expand(
+        self,
+        results: Sequence[SearchResult],
+        *,
+        top_n: int = 10,
+        max_related: int = 50,
+    ) -> List[SearchResult]:
+        """Expand top-N results with related symbols from global relationships.
+
+        Args:
+            results: Base ranked results from Stage 1.
+            top_n: Only expand the top-N base results.
+            max_related: Maximum related results to return.
+
+        Returns:
+            List of related SearchResult objects (does NOT include the input results).
+        """
+        if not results:
+            return []
+
+        # 1. Extract symbol names from top results
+        symbols_with_scores = self._resolve_symbols(results, top_n)
+        if not symbols_with_scores:
+            return []
+
+        symbol_names = [s[0] for s in symbols_with_scores]
+        base_scores = {s[0]: s[1] for s in symbols_with_scores}
+
+        # 2. Query global relationships
+        relationships = self._query_relationships(symbol_names, limit=max_related * 3)
+        if not relationships:
+            return []
+
+        # 3. Build expanded results with score decay
+        expanded = self._build_expanded_results(
+            relationships, base_scores, max_related
+        )
+
+        # 4. Deduplicate against input results
+        input_keys: set[Tuple[str, Optional[str], Optional[int]]] = set()
+        for r in results:
+            input_keys.add((r.path, r.symbol_name, r.start_line))
+
+        deduped: List[SearchResult] = []
+        seen: set[Tuple[str, Optional[str], Optional[int]]] = set()
+        for r in expanded:
+            key = (r.path, r.symbol_name, r.start_line)
+            if key not in input_keys and key not in seen:
+                seen.add(key)
+                deduped.append(r)
+
+        return deduped[:max_related]
+
+    def _resolve_symbols(
+        self,
+        results: Sequence[SearchResult],
+        top_n: int,
+    ) -> List[Tuple[str, float]]:
+        """Extract (symbol_name, score) pairs from top results."""
+        symbols: List[Tuple[str, float]] = []
+        seen: set[str] = set()
+        for r in list(results)[:top_n]:
+            name = r.symbol_name
+            if not name or name in seen:
+                continue
+            seen.add(name)
+            symbols.append((name, float(r.score)))
+        return symbols
+
+    def _query_relationships(
+        self,
+        symbol_names: List[str],
+        limit: int = 150,
+    ) -> List[sqlite3.Row]:
+        """Query global_relationships for symbols."""
+        try:
+            return self._global_index.query_relationships_for_symbols(
+                symbol_names, limit=limit
+            )
+        except Exception as exc:
+            self._logger.debug("Global graph query failed: %s", exc)
+            return []
+
+    def _resolve_target_to_file(
+        self,
+        target_qualified_name: str,
+    ) -> Optional[Tuple[str, int, int]]:
+        """Resolve target_qualified_name to (file_path, start_line, end_line).
+
+        Tries ``file_path::symbol_name`` format first, then falls back to
+        symbol name search in the global index.
+        """
+        # Format: "file_path::symbol_name"
+        if "::" in target_qualified_name:
+            parts = target_qualified_name.split("::", 1)
+            target_file = parts[0]
+            target_symbol = parts[1]
+            try:
+                symbols = self._global_index.search(target_symbol, limit=5)
+                for sym in symbols:
+                    if sym.file and str(sym.file) == target_file:
+                        return (
+                            target_file,
+                            sym.range[0] if sym.range else 1,
+                            sym.range[1] if sym.range else 1,
+                        )
+                # File path known but line info unavailable
+                return (target_file, 1, 1)
+            except Exception:
+                return (target_file, 1, 1)
+
+        # Plain symbol name (possibly dot-qualified like "mod.ClassName")
+        try:
+            leaf_name = target_qualified_name.rsplit(".", 1)[-1]
+            symbols = self._global_index.search(leaf_name, limit=5)
+            if symbols:
+                sym = symbols[0]
+                file_path = str(sym.file) if sym.file else None
+                if file_path:
+                    return (
+                        file_path,
+                        sym.range[0] if sym.range else 1,
+                        sym.range[1] if sym.range else 1,
+                    )
+        except Exception:
+            pass
+
+        return None
+
+    def _build_expanded_results(
+        self,
+        relationships: List[sqlite3.Row],
+        base_scores: Dict[str, float],
+        max_related: int,
+    ) -> List[SearchResult]:
+        """Build SearchResult list from relationships with score decay."""
+        results: List[SearchResult] = []
+
+        for rel in relationships:
+            source_file = rel["source_file"]
+            source_symbol = rel["source_symbol"]
+            target_qname = rel["target_qualified_name"]
+            rel_type = rel["relationship_type"]
+            source_line = rel["source_line"]
+
+            # Determine base score from the matched symbol
+            base_score = base_scores.get(source_symbol, 0.0)
+            if base_score == 0.0:
+                # Try matching against the target leaf name
+                leaf = target_qname.rsplit(".", 1)[-1] if "." in target_qname else target_qname
+                if "::" in leaf:
+                    leaf = leaf.split("::")[-1]
+                base_score = base_scores.get(leaf, 0.0)
+            if base_score == 0.0:
+                base_score = 0.5  # Default when no match found
+
+            # Apply decay factor
+            decay = DECAY_FACTORS.get(rel_type, DEFAULT_DECAY)
+            score = base_score * decay
+
+            # Try to resolve target to file for a richer result
+            target_info = self._resolve_target_to_file(target_qname)
+            if target_info:
+                t_file, t_start, t_end = target_info
+                results.append(SearchResult(
+                    path=t_file,
+                    score=score,
+                    excerpt=None,
+                    content=None,
+                    start_line=t_start,
+                    end_line=t_end,
+                    symbol_name=(
+                        target_qname.split("::")[-1]
+                        if "::" in target_qname
+                        else target_qname.rsplit(".", 1)[-1]
+                    ),
+                    symbol_kind=None,
+                    metadata={
+                        "source": "static_graph",
+                        "relationship_type": rel_type,
+                        "from_symbol": source_symbol,
+                        "from_file": source_file,
+                    },
+                ))
+            else:
+                # Use source file as fallback (we know the source exists)
+                results.append(SearchResult(
+                    path=source_file,
+                    score=score * 0.8,  # Slight penalty for unresolved target
+                    excerpt=None,
+                    content=None,
+                    start_line=source_line,
+                    end_line=source_line,
+                    symbol_name=source_symbol,
+                    symbol_kind=None,
+                    metadata={
+                        "source": "static_graph",
+                        "relationship_type": rel_type,
+                        "target_qualified_name": target_qname,
+                    },
+                ))
+
+            if len(results) >= max_related:
+                break
+
+        # Sort by score descending
+        results.sort(key=lambda r: r.score, reverse=True)
+        return results

package/codex-lens/src/codexlens/search/hybrid_search.py

@@ -35,7 +35,6 @@ from codexlens.config import VECTORS_HNSW_NAME
 from codexlens.entities import SearchResult
 from codexlens.search.ranking import (
     DEFAULT_WEIGHTS,
-    FTS_FALLBACK_WEIGHTS,
     QueryIntent,
     apply_symbol_boost,
     cross_encoder_rerank,
@@ -57,14 +56,6 @@ except ImportError:
     HAS_LSP = False
 
 
-# Three-way fusion weights (FTS + Vector + SPLADE)
-THREE_WAY_WEIGHTS = {
-    "exact": 0.2,
-    "splade": 0.3,
-    "vector": 0.5,
-}
-
-
 class HybridSearchEngine:
     """Hybrid search engine with parallel execution and RRF fusion.
 
@@ -77,8 +68,7 @@ class HybridSearchEngine:
     """
 
     # NOTE: DEFAULT_WEIGHTS imported from ranking.py - single source of truth
-    # Default RRF weights: SPLADE-based hybrid (splade: 0.4, vector: 0.6)
-    # FTS fallback mode uses FTS_FALLBACK_WEIGHTS (exact: 0.3, fuzzy: 0.1, vector: 0.6)
+    # FTS + vector hybrid mode (exact: 0.3, fuzzy: 0.1, vector: 0.6)
 
     def __init__(
         self,
@@ -119,7 +109,6 @@ class HybridSearchEngine:
         enable_fuzzy: bool = True,
         enable_vector: bool = False,
         pure_vector: bool = False,
-        enable_splade: bool = False,
         enable_lsp_graph: bool = False,
         lsp_max_depth: int = 1,
         lsp_max_nodes: int = 20,
@@ -133,7 +122,6 @@ class HybridSearchEngine:
             enable_fuzzy: Enable fuzzy FTS search (default True)
             enable_vector: Enable vector search (default False)
             pure_vector: If True, only use vector search without FTS fallback (default False)
-            enable_splade: If True, force SPLADE sparse neural search (default False)
             enable_lsp_graph: If True, enable real-time LSP graph expansion (default False)
             lsp_max_depth: Maximum depth for LSP graph BFS expansion (default 1)
             lsp_max_nodes: Maximum nodes to collect in LSP graph (default 20)
@@ -150,9 +138,6 @@ class HybridSearchEngine:
             >>> results = engine.search(Path("project/_index.db"),
             ...                         "how to authenticate users",
             ...                         enable_vector=True, pure_vector=True)
-            >>> # SPLADE sparse neural search
-            >>> results = engine.search(Path("project/_index.db"), "auth flow",
-            ...                         enable_splade=True, enable_vector=True)
             >>> # With LSP graph expansion (real-time)
             >>> results = engine.search(Path("project/_index.db"), "auth flow",
             ...                         enable_vector=True, enable_lsp_graph=True)
@@ -180,26 +165,6 @@ class HybridSearchEngine:
         # Determine which backends to use
         backends = {}
 
-        # Check if SPLADE is available
-        splade_available = False
-        # Respect config.enable_splade flag and use_fts_fallback flag
-        if self._config and getattr(self._config, 'use_fts_fallback', False):
-            # Config explicitly requests FTS fallback - disable SPLADE
-            splade_available = False
-        elif self._config and not getattr(self._config, 'enable_splade', True):
-            # Config explicitly disabled SPLADE
-            splade_available = False
-        else:
-            # Check if SPLADE dependencies are available
-            try:
-                from codexlens.semantic.splade_encoder import check_splade_available
-                ok, _ = check_splade_available()
-                if ok:
-                    # SPLADE tables are in main index database, will check table existence in _search_splade
-                    splade_available = True
-            except Exception:
-                pass
-
         if pure_vector:
             # Pure vector mode: only use vector search, no FTS fallback
             if enable_vector:
@@ -212,37 +177,13 @@ class HybridSearchEngine:
                     "To use pure vector search, enable vector search mode."
                 )
                 backends["exact"] = True
-        elif enable_splade:
-            # Explicit SPLADE mode requested via CLI --method splade
-            if splade_available:
-                backends["splade"] = True
-                if enable_vector:
-                    backends["vector"] = True
-            else:
-                # SPLADE requested but not available - warn and fallback
-                self.logger.warning(
-                    "SPLADE search requested but not available. "
-                    "Falling back to FTS. Run 'codexlens index splade' to enable."
-                )
-                backends["exact"] = True
-                if enable_fuzzy:
-                    backends["fuzzy"] = True
-                if enable_vector:
-                    backends["vector"] = True
         else:
-            # Hybrid mode: default to SPLADE if available, otherwise use FTS
-            if splade_available:
-                # Default: enable SPLADE, disable exact and fuzzy
-                backends["splade"] = True
-                if enable_vector:
-                    backends["vector"] = True
-            else:
-                # Fallback mode: enable exact+fuzzy when SPLADE unavailable
-                backends["exact"] = True
-                if enable_fuzzy:
-                    backends["fuzzy"] = True
-                if enable_vector:
-                    backends["vector"] = True
+            # Standard hybrid mode: FTS + optional vector
+            backends["exact"] = True
+            if enable_fuzzy:
+                backends["fuzzy"] = True
+            if enable_vector:
+                backends["vector"] = True
 
         # Add LSP graph expansion if requested and available
         if enable_lsp_graph and HAS_LSP:
@@ -502,13 +443,6 @@ class HybridSearchEngine:
                 )
                 future_to_source[future] = "vector"
 
-            if backends.get("splade"):
-                submit_times["splade"] = time.perf_counter()
-                future = executor.submit(
-                    self._search_splade, index_path, query, limit
-                )
-                future_to_source[future] = "splade"
-
             if backends.get("lsp_graph"):
                 submit_times["lsp_graph"] = time.perf_counter()
                 future = executor.submit(
@@ -599,8 +533,7 @@ class HybridSearchEngine:
     def _find_vectors_hnsw(self, index_path: Path) -> Optional[Path]:
         """Find the centralized _vectors.hnsw file by traversing up from index_path.
 
-        Similar to _search_splade's approach, this method searches for the
-        centralized dense vector index file in parent directories.
+        Searches for the centralized dense vector index file in parent directories.
 
         Args:
             index_path: Path to the current _index.db file
@@ -1138,124 +1071,6 @@ class HybridSearchEngine:
             self.logger.error("Vector search error: %s", exc)
             return []
 
-    def _search_splade(
-        self, index_path: Path, query: str, limit: int
-    ) -> List[SearchResult]:
-        """SPLADE sparse retrieval via inverted index.
-        
-        Args:
-            index_path: Path to _index.db file
-            query: Natural language query string
-            limit: Maximum results
-        
-        Returns:
-            List of SearchResult ordered by SPLADE score
-        """
-        try:
-            from codexlens.semantic.splade_encoder import get_splade_encoder, check_splade_available
-            from codexlens.storage.splade_index import SpladeIndex
-            from codexlens.config import SPLADE_DB_NAME
-            import sqlite3
-            import json
-
-            # Check dependencies
-            ok, err = check_splade_available()
-            if not ok:
-                self.logger.debug("SPLADE not available: %s", err)
-                return []
-
-            # SPLADE index is stored in _splade.db at the project index root
-            # Traverse up from the current index to find the root _splade.db
-            current_dir = index_path.parent
-            splade_db_path = None
-            for _ in range(10):  # Limit search depth
-                candidate = current_dir / SPLADE_DB_NAME
-                if candidate.exists():
-                    splade_db_path = candidate
-                    break
-                parent = current_dir.parent
-                if parent == current_dir:  # Reached root
-                    break
-                current_dir = parent
-
-            if not splade_db_path:
-                self.logger.debug("SPLADE index not found in ancestor directories of %s", index_path)
-                return []
-
-            splade_index = SpladeIndex(splade_db_path)
-            if not splade_index.has_index():
-                self.logger.debug("SPLADE index not initialized")
-                return []
-            
-            # Encode query to sparse vector
-            encoder = get_splade_encoder(use_gpu=self._use_gpu)
-            query_sparse = encoder.encode_text(query)
-            
-            # Search inverted index for top matches
-            raw_results = splade_index.search(query_sparse, limit=limit, min_score=0.0)
-            
-            if not raw_results:
-                return []
-
-            # Fetch chunk details from splade_chunks table (self-contained)
-            chunk_ids = [chunk_id for chunk_id, _ in raw_results]
-            score_map = {chunk_id: score for chunk_id, score in raw_results}
-
-            # Get chunk metadata from SPLADE database
-            rows = splade_index.get_chunks_by_ids(chunk_ids)
-
-            # Build SearchResult objects
-            results = []
-            for row in rows:
-                chunk_id = row["id"]
-                file_path = row["file_path"]
-                content = row["content"]
-                metadata_json = row["metadata"]
-                metadata = json.loads(metadata_json) if metadata_json else {}
-
-                score = score_map.get(chunk_id, 0.0)
-                
-                # Build excerpt (short preview)
-                excerpt = content[:200] + "..." if len(content) > 200 else content
-                
-                # Extract symbol information from metadata
-                symbol_name = metadata.get("symbol_name")
-                symbol_kind = metadata.get("symbol_kind")
-                start_line = metadata.get("start_line")
-                end_line = metadata.get("end_line")
-                
-                # Build Symbol object if we have symbol info
-                symbol = None
-                if symbol_name and symbol_kind and start_line and end_line:
-                    try:
-                        from codexlens.entities import Symbol
-                        symbol = Symbol(
-                            name=symbol_name,
-                            kind=symbol_kind,
-                            range=(start_line, end_line)
-                        )
-                    except Exception:
-                        pass
-                
-                results.append(SearchResult(
-                    path=file_path,
-                    score=score,
-                    excerpt=excerpt,
-                    content=content,
-                    symbol=symbol,
-                    metadata=metadata,
-                    start_line=start_line,
-                    end_line=end_line,
-                    symbol_name=symbol_name,
-                    symbol_kind=symbol_kind,
-                ))
-            
-            return results
-
-        except Exception as exc:
-            self.logger.debug("SPLADE search error: %s", exc)
-            return []
-
     def _search_lsp_graph(
         self,
         index_path: Path,
@@ -1295,21 +1110,14 @@ class HybridSearchEngine:
             if seeds:
                 seed_source = "vector"
 
-            # 2. Fallback to SPLADE if vector returns nothing
-            if not seeds:
-                self.logger.debug("Vector search returned no seeds, trying SPLADE")
-                seeds = self._search_splade(index_path, query, limit=3)
-                if seeds:
-                    seed_source = "splade"
-
-            # 3. Fallback to exact FTS if SPLADE also fails
+            # 2. Fallback to exact FTS if vector returns nothing
             if not seeds:
-                self.logger.debug("SPLADE returned no seeds, trying exact FTS")
+                self.logger.debug("Vector search returned no seeds, trying exact FTS")
                 seeds = self._search_exact(index_path, query, limit=3)
                 if seeds:
                     seed_source = "exact_fts"
 
-            # 4. No seeds available from any source
+            # 3. No seeds available from any source
             if not seeds:
                 self.logger.debug("No seed results available for LSP graph expansion")
                 return []

package/codex-lens/src/codexlens/search/ranking.py

@@ -1,7 +1,7 @@
 """Ranking algorithms for hybrid search result fusion.
 
 Implements Reciprocal Rank Fusion (RRF) and score normalization utilities
-for combining results from heterogeneous search backends (SPLADE, exact FTS, fuzzy FTS, vector search).
+for combining results from heterogeneous search backends (exact FTS, fuzzy FTS, vector search).
 """
 
 from __future__ import annotations
@@ -15,19 +15,12 @@ from typing import Any, Dict, List, Optional
 from codexlens.entities import SearchResult, AdditionalLocation
 
 
-# Default RRF weights for SPLADE-based hybrid search
+# Default RRF weights for hybrid search
 DEFAULT_WEIGHTS = {
-    "splade": 0.35,  # Replaces exact(0.3) + fuzzy(0.1)
-    "vector": 0.5,
-    "lsp_graph": 0.15,  # Real-time LSP-based graph expansion
-}
-
-# Legacy weights for FTS fallback mode (when SPLADE unavailable)
-FTS_FALLBACK_WEIGHTS = {
     "exact": 0.25,
     "fuzzy": 0.1,
     "vector": 0.5,
-    "lsp_graph": 0.15,  # Real-time LSP-based graph expansion
+    "lsp_graph": 0.15,
 }
 
 
@@ -105,22 +98,13 @@ def adjust_weights_by_intent(
     base_weights: Dict[str, float],
 ) -> Dict[str, float]:
     """Adjust RRF weights based on query intent."""
-    # Check if using SPLADE or FTS mode
-    use_splade = "splade" in base_weights
-    
     if intent == QueryIntent.KEYWORD:
-        if use_splade:
-            target = {"splade": 0.6, "vector": 0.4}
-        else:
-            target = {"exact": 0.5, "fuzzy": 0.1, "vector": 0.4}
+        target = {"exact": 0.5, "fuzzy": 0.1, "vector": 0.4}
     elif intent == QueryIntent.SEMANTIC:
-        if use_splade:
-            target = {"splade": 0.3, "vector": 0.7}
-        else:
-            target = {"exact": 0.2, "fuzzy": 0.1, "vector": 0.7}
+        target = {"exact": 0.2, "fuzzy": 0.1, "vector": 0.7}
     else:
         target = dict(base_weights)
-    
+
     # Filter to active backends
     keys = list(base_weights.keys())
     filtered = {k: float(target.get(k, 0.0)) for k in keys}
@@ -225,7 +209,7 @@ def simple_weighted_fusion(
 
     Args:
         results_map: Dictionary mapping source name to list of SearchResult objects
-                     Sources: 'exact', 'fuzzy', 'vector', 'splade'
+                     Sources: 'exact', 'fuzzy', 'vector'
         weights: Dictionary mapping source name to weight (default: equal weights)
                  Example: {'exact': 0.3, 'fuzzy': 0.1, 'vector': 0.6}
 
@@ -331,14 +315,11 @@ def reciprocal_rank_fusion(
 
     RRF formula: score(d) = Σ weight_source / (k + rank_source(d))
 
-    Supports three-way fusion with FTS, Vector, and SPLADE sources.
-
     Args:
         results_map: Dictionary mapping source name to list of SearchResult objects
-                     Sources: 'exact', 'fuzzy', 'vector', 'splade'
+                     Sources: 'exact', 'fuzzy', 'vector'
         weights: Dictionary mapping source name to weight (default: equal weights)
                  Example: {'exact': 0.3, 'fuzzy': 0.1, 'vector': 0.6}
-                 Or: {'splade': 0.4, 'vector': 0.6}
         k: Constant to avoid division by zero and control rank influence (default 60)
 
     Returns:
@@ -349,14 +330,6 @@ def reciprocal_rank_fusion(
         >>> fuzzy_results = [SearchResult(path="b.py", score=8.0, excerpt="...")]
         >>> results_map = {'exact': exact_results, 'fuzzy': fuzzy_results}
         >>> fused = reciprocal_rank_fusion(results_map)
-
-        # Three-way fusion with SPLADE
-        >>> results_map = {
-        ...     'exact': exact_results,
-        ...     'vector': vector_results,
-        ...     'splade': splade_results
-        ... }
-        >>> fused = reciprocal_rank_fusion(results_map, k=60)
     """
     if not results_map:
         return []