Hybrid Search

def run_search(
    query: str,
    limit: int = 10,
    strict: bool = False,
    rerank: bool = False,
    debug: bool = False,
    json_output: bool = False,
    include_personal: bool = False,
    skills_only: bool = False,
) -> None

def collect_canonical(query: str) -> list[SearchResult]:
    """Collect matches from CANONICAL.md — requires 2+ keyword hits per line."""
    # Filters stopwords, scores by keyword density
    # Returns top 3 results

def collect_tags(query: str) -> list[SearchResult]:
    """Collect exact tag matches from sharded indexes."""
    # Uses subprocess.run with grep for speed
    # Returns up to 10 matches per shard

def collect_vectors(
    query: str,
    limit: int = 20,
    embedding: list[float] | None = None,
    exclude_domains: list[str] | None = None,
    skills_only: bool = False,
) -> list[SearchResult]:
    """Collect semantic matches via Supabase"""

def collect_graphrag(query: str, limit: int = 5) -> list[SearchResult]:
    """Collect entity and community matches via query_graphrag.py subprocess."""
    # Runs with --global-only flag for speed
    # 5-second timeout

def collect_filenames(query: str) -> list[SearchResult]:
    """Collect filename matches in Project Root — splits query into keyword tokens."""
    # Scores by keyword density in filename
    # Returns top 10

def weighted_rrf(
    ranked_lists: dict[str, list[SearchResult]], k: int = 60
) -> list[SearchResult]:
    fused_scores = defaultdict(float)
    
    for source, docs in ranked_lists.items():
        weight = WEIGHTS.get(source, 1.0)
        for rank, doc in enumerate(docs, start=1):
            score_mod = 0.5 + doc.score  # Range: 0.5 to 1.5
            contrib = weight * score_mod * (1.0 / (k + rank))
            fused_scores[doc.id] += contrib
    
    return sorted(fused_scores.items(), key=lambda x: x[1], reverse=True)

RRF_score = Σ (weight_source × score_mod × 1/(k + rank_source))

cache_key = f"{query}|{limit}|{strict}|{rerank}|{skills_only}"
cached_results = cache.get(cache_key)

query_embedding = get_embedding(query)
semantic_hit = cache.get_semantic(query_embedding)

GOD_MODE = True

if GOD_MODE:
    mid_limit = 3  # vs 5 in normal mode
    low_limit = 3  # vs 5 in normal mode
    timeout = 5    # vs 8 in normal mode

word_count = len(query.split())
is_low_entropy = word_count < 5 and not any(
    x in query.lower() for x in ["protocol", "session", "case study", "cs-"]
)

if is_low_entropy:
    print("⚡ Low Entropy Query: Skipping deep retrieval")

with ThreadPoolExecutor(max_workers=len(collection_tasks)) as executor:
    done, not_done = wait(
        future_to_source.keys(), 
        timeout=5,  # God Mode timeout
        return_when=ALL_COMPLETED
    )

if rerank and fused_results:
    from athena.tools.reranker import rerank_results
    candidates = fused_results[:25]
    fused_results = rerank_results(query, candidates, top_k=limit)

CONFIDENCE_HIGH = 0.03
CONFIDENCE_MED = 0.02
CONFIDENCE_LOW = 0.01

if strict:
    fused_results = [r for r in fused_results if r.rrf_score >= CONFIDENCE_MED]

python -m athena.tools.search "trend continuation patterns"

python -m athena.tools.search "risk management" --rerank --limit 5

python -m athena.tools.search "protocol 137" --strict

python -m athena.tools.search "trading psychology" --json

python -m athena.tools.search "case studies" --debug

🔍 SMART SEARCH (Parallel Hybrid RRF): "trading risk management"
============================================================

<athena_grounding>

🏆 TOP 10 RESULTS:

  1. [HIGH] [RRF:0.0421] Protocol 49: Risk Management Framework
     📁 .agent/skills/protocols/049-risk-management.md

  2. [MED] [RRF:0.0287] Case Study: Position Sizing Analysis
     📁 .context/case_studies/cs-002.md

{
  "results": [
    {
      "id": "Protocol 49: Risk Management Framework",
      "content": "Risk management protocol for...",
      "source": "protocol",
      "score": 0.95,
      "rrf_score": 0.0421,
      "metadata": {
        "path": ".agent/skills/protocols/049-risk-management.md",
        "type": "protocol"
      },
      "signals": {
        "protocol": {"rank": 1, "contrib": 0.0287}
      }
    }
  ],
  "suppressed": 0
}