run_benchmark.py

"""Run the curated query set through federated_search and capture per-source diagnostics.

Produces a JSON corpus (one record per query) suitable for HF Dataset upload.
Each record captures:
  - query + domain + expected_strong_sources
  - per-source raw count (before dedup)
  - deduplicated count
  - top 10 deduplicated papers with title/year/source/url/doi
  - timing (wall-clock seconds per source)
"""
from __future__ import annotations

import json
import logging
import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path

from research_papers_mcp.sources import REGISTRY

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)

QUERIES_PATH = Path("/Users/baris/Projects/research-papers-mcp-benchmark/queries.json")
OUT_PATH = Path("/Users/baris/Projects/research-papers-mcp-benchmark/traces.json")
MAX_RESULTS_PER_SOURCE = 15
TOP_N_PAPERS = 10


def _dedupe(papers):
    """Same dedup logic as the live federated_search."""
    seen_dois = set()
    seen_source_ids = set()
    out = []
    for p in papers:
        doi = (p.get("doi") or "").lower().strip() or None
        sid = (p.get("source"), p.get("source_id"))
        if doi and doi in seen_dois:
            continue
        if sid in seen_source_ids:
            continue
        if doi:
            seen_dois.add(doi)
        seen_source_ids.add(sid)
        out.append(p)
    return out


def run_query(query: str, sources: dict):
    """Call each registered source concurrently. Return per-source results + timing."""
    per_source_results = {}
    per_source_timing = {}

    with ThreadPoolExecutor(max_workers=len(sources)) as ex:
        futures = {}
        for name, src in sources.items():
            start = time.time()
            fut = ex.submit(src.search, query, MAX_RESULTS_PER_SOURCE, None)
            futures[fut] = (name, start)

        for fut in as_completed(futures):
            name, start = futures[fut]
            try:
                results = fut.result()
                per_source_results[name] = results
            except Exception as e:
                logger.warning("source %s failed for %s: %s", name, query, e)
                per_source_results[name] = []
            per_source_timing[name] = round(time.time() - start, 2)

    return per_source_results, per_source_timing


def main():
    queries_data = json.loads(QUERIES_PATH.read_text())
    queries = queries_data["queries"]
    logger.info("loaded %d queries", len(queries))

    records = []
    for i, q in enumerate(queries, 1):
        logger.info("[%d/%d] %s", i, len(queries), q["query"])
        per_source, timings = run_query(q["query"], REGISTRY)

        # Counts
        raw_counts = {name: len(results) for name, results in per_source.items()}
        raw_total = sum(raw_counts.values())

        # Dedupe across sources
        all_papers = []
        for results in per_source.values():
            all_papers.extend(results)
        deduped = _dedupe(all_papers)

        # Capture top N deduplicated papers (compact form)
        top = []
        for p in deduped[:TOP_N_PAPERS]:
            top.append({
                "title": (p.get("title") or "")[:300],
                "year": p.get("year"),
                "source": p.get("source"),
                "doi": p.get("doi"),
                "url": p.get("url") or p.get("doi_url"),
            })

        records.append({
            "id": q["id"],
            "query": q["query"],
            "domain": q["domain"],
            "expected_strong_sources": q.get("expected_strong_sources", []),
            "per_source_raw_count": raw_counts,
            "raw_total": raw_total,
            "deduped_count": len(deduped),
            "duplicates_removed": raw_total - len(deduped),
            "per_source_timing_sec": timings,
            "top_papers": top,
        })

        # Be polite — pause between queries so rate-limited sources recover
        time.sleep(10)

    OUT_PATH.write_text(json.dumps(records, indent=2))
    logger.info("wrote %d records to %s", len(records), OUT_PATH)

    # Summary stats
    total_raw = sum(r["raw_total"] for r in records)
    total_dedup = sum(r["deduped_count"] for r in records)
    print(f"\n=== summary ===")
    print(f"queries: {len(records)}")
    print(f"raw total papers: {total_raw}")
    print(f"deduplicated total: {total_dedup}")
    print(f"duplicates removed: {total_raw - total_dedup} ({(total_raw - total_dedup) / max(total_raw, 1):.1%})")


if __name__ == "__main__":
    main()