From 99e6d98947973396b84adc1b92d376976e6a2f66 Mon Sep 17 00:00:00 2001 From: suguanYang Date: Tue, 8 Sep 2026 16:21:29 +0800 Subject: [PATCH 01/15] perf: process scanned OCR one page at a time --- .../document_agent/tools/ocr_pages.py | 46 +++++++------- .../tests/contract/test_ocr_pages_contract.py | 61 +++++++++++++++---- 2 files changed, 72 insertions(+), 35 deletions(-) diff --git a/apps/worker/app/services/document_agent/tools/ocr_pages.py b/apps/worker/app/services/document_agent/tools/ocr_pages.py index 80565118..bd397dd8 100644 --- a/apps/worker/app/services/document_agent/tools/ocr_pages.py +++ b/apps/worker/app/services/document_agent/tools/ocr_pages.py @@ -37,25 +37,22 @@ def _line_score(item: Any) -> float: @worker -def _run_ocr_worker(queue: Any, page_paths: dict[int, str]) -> None: +def _run_ocr_worker(queue: Any, page: int, image_path: str) -> None: """Run the local OCR model outside the heartbeat-bearing worker process.""" from rapidocr_onnxruntime import RapidOCR - engine = RapidOCR(intra_op_num_threads=2, inter_op_num_threads=1) - page_lines: dict[int, list[dict[str, Any]]] = {} - for page, image_path in page_paths.items(): - lines: list[dict[str, Any]] = [] - result, _elapse = engine(image_path) - for item in result or []: - lines.append( - { - "box": _line_box(item), - "text": _line_text(item), - "score": _line_score(item), - } - ) - page_lines[page] = lines - queue.put({"ok": True, "page_lines": page_lines}) + engine = RapidOCR(intra_op_num_threads=1, inter_op_num_threads=1) + lines: list[dict[str, Any]] = [] + result, _elapse = engine(image_path) + for item in result or []: + lines.append( + { + "box": _line_box(item), + "text": _line_text(item), + "score": _line_score(item), + } + ) + queue.put({"ok": True, "page": page, "lines": lines}) @register_tool( @@ -96,14 +93,15 @@ def ocr_pages(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: if item.get("page") is not None and item.get("png_path") } - page_paths = { - page: image_path for page, image_path in png_by_page.items() if page in pages - } - result = run_in_child_process(_run_ocr_worker, page_paths, timeout=300) - page_lines = { - int(page): list(lines) - for page, lines in (result.get("page_lines") or {}).items() - } + page_lines: dict[int, list[dict[str, Any]]] = {} + for page in pages: + image_path = png_by_page.get(page) + if not image_path: + page_lines[page] = [] + continue + result = run_in_child_process(_run_ocr_worker, page, image_path, timeout=300) + result_page = int(result.get("page") or page) + page_lines[result_page] = list(result.get("lines") or []) page_texts: dict[int, str] = {} page_bands: dict[int, PageTextBands] = {} for page in pages: diff --git a/apps/worker/tests/contract/test_ocr_pages_contract.py b/apps/worker/tests/contract/test_ocr_pages_contract.py index 1fbcde9c..c84197ee 100644 --- a/apps/worker/tests/contract/test_ocr_pages_contract.py +++ b/apps/worker/tests/contract/test_ocr_pages_contract.py @@ -56,21 +56,24 @@ def test_ocr_pages_writes_joined_text_to_blackboard() -> None: def fake_render(*_args, **_kwargs): return [{"page": 1, "png_path": "/tmp/ocr_page_1.png"}] - def fake_child(worker_fn, page_paths, *, timeout): + calls: list[tuple[int, str, int]] = [] + + def fake_child(worker_fn, page, image_path, *, timeout): assert worker_fn.__name__ == "_run_ocr_worker" - assert page_paths == {1: "/tmp/ocr_page_1.png"} + calls.append((page, image_path, timeout)) + assert page == 1 + assert image_path == "/tmp/ocr_page_1.png" assert timeout == 300 return { "ok": True, - "page_lines": { - 1: [ - { - "box": [[0, 0], [1, 0], [1, 1], [0, 1]], - "text": "Hello", - "score": 0.9, - } - ] - }, + "page": page, + "lines": [ + { + "box": [[0, 0], [1, 0], [1, 1], [0, 1]], + "text": "Hello", + "score": 0.9, + } + ], } with ( @@ -85,3 +88,39 @@ def fake_child(worker_fn, page_paths, *, timeout): assert getattr(bands, "header", None) == "" assert getattr(bands, "footer", None) == "" assert result.payload["page_lines"][1][0]["text"] == "Hello" + assert calls == [(1, "/tmp/ocr_page_1.png", 300)] + + +def test_ocr_pages_runs_one_child_per_page() -> None: + ctx = _ctx() + calls: list[tuple[int, str]] = [] + + def fake_render(*_args: object, **_kwargs: object) -> list[dict[str, object]]: + return [ + {"page": 1, "png_path": "/tmp/ocr_page_1.png"}, + {"page": 2, "png_path": "/tmp/ocr_page_2.png"}, + ] + + def fake_child( + worker_fn: object, + page: int, + image_path: str, + *, + timeout: int, + ) -> dict[str, object]: + assert getattr(worker_fn, "__name__", None) == "_run_ocr_worker" + assert timeout == 300 + calls.append((page, image_path)) + return {"ok": True, "page": page, "lines": []} + + with ( + patch.dict(ocr_pages.__globals__, {"render_pages": fake_render}), + patch.dict(ocr_pages.__globals__, {"run_in_child_process": fake_child}), + ): + result = ocr_pages(ctx, {"pages": [1, 2]}) + + assert result.status == "ok" + assert calls == [ + (1, "/tmp/ocr_page_1.png"), + (2, "/tmp/ocr_page_2.png"), + ] From eca70af64e0e3ac1c5a7d52ec5c76402ff1e4036 Mon Sep 17 00:00:00 2001 From: suguanYang Date: Tue, 8 Sep 2026 17:01:32 +0800 Subject: [PATCH 02/15] perf: reuse persistent OCR child --- .../document_agent/tools/ocr_pages.py | 206 ++++++++++++++++-- .../tests/contract/test_ocr_pages_contract.py | 56 +++-- 2 files changed, 207 insertions(+), 55 deletions(-) diff --git a/apps/worker/app/services/document_agent/tools/ocr_pages.py b/apps/worker/app/services/document_agent/tools/ocr_pages.py index bd397dd8..972f070a 100644 --- a/apps/worker/app/services/document_agent/tools/ocr_pages.py +++ b/apps/worker/app/services/document_agent/tools/ocr_pages.py @@ -2,17 +2,190 @@ from __future__ import annotations +import atexit +import multiprocessing +import queue as queue_module import time +from dataclasses import dataclass +from multiprocessing.process import BaseProcess +from multiprocessing.queues import Queue as MultiprocessingQueue +from threading import RLock from typing import Any +from loguru import logger + from app.services.document_agent.manifest import ToolContext, ToolResult from app.services.document_agent.pdf_text import PageTextBands -from app.services.document_parser.formats.pdf.pymupdf_subprocess import ( - run_in_child_process, - worker, -) from app.services.document_agent.registry import has_page_features, register_tool from app.services.document_agent.visual import render_pages +from shared.core.exceptions.domain_exceptions import PDFParsingException, TimeoutException + + +OCR_TIMEOUT_SECONDS = 300 +OCR_RUNNER_CONTEXT = multiprocessing.get_context("spawn") + + +@dataclass(frozen=True) +class _OcrRequestResult: + status: str + result: dict[str, Any] | None = None + + +def _run_ocr_process( + request_queue: MultiprocessingQueue, + response_queue: MultiprocessingQueue, +) -> None: + """Serve sequential OCR requests while keeping one model instance alive.""" + from rapidocr_onnxruntime import RapidOCR + + engine = RapidOCR(intra_op_num_threads=1, inter_op_num_threads=1) + while True: + request = request_queue.get() + if request is None: + return + page = int(request["page"]) + image_path = str(request["image_path"]) + try: + result, _elapse = engine(image_path) + lines: list[dict[str, Any]] = [] + for item in result or []: + lines.append( + { + "box": _line_box(item), + "text": _line_text(item), + "score": _line_score(item), + } + ) + response_queue.put({"ok": True, "page": page, "lines": lines}) + except Exception as exc: + response_queue.put( + { + "ok": False, + "page": page, + "error_type": type(exc).__name__, + "error_msg": str(exc), + } + ) + + +class _OcrRunner: + """Own one persistent OCR child and serialize page requests through it.""" + + def __init__(self) -> None: + self._process: BaseProcess | None = None + self._request_queue: MultiprocessingQueue | None = None + self._response_queue: MultiprocessingQueue | None = None + self._executor: Any | None = None + self._lock = RLock() + + def run_page(self, page: int, image_path: str, *, timeout: int) -> dict[str, Any]: + executor = self._get_executor() + return executor.apply(self._run_page_blocking, (page, image_path, timeout)) + + def close(self) -> None: + with self._lock: + process = self._process + request_queue = self._request_queue + response_queue = self._response_queue + self._process = None + self._request_queue = None + self._response_queue = None + if process is not None and process.is_alive() and request_queue is not None: + request_queue.put(None) + process.join(timeout=5) + if process is not None and process.is_alive(): + process.kill() + process.join(timeout=5) + for result_queue in (request_queue, response_queue): + if result_queue is not None: + result_queue.close() + + def _get_executor(self) -> Any: + if self._executor is None: + from gevent.threadpool import ThreadPool + + self._executor = ThreadPool(maxsize=1) + return self._executor + + def _run_page_blocking(self, page: int, image_path: str, timeout: int) -> dict[str, Any]: + with self._lock: + self._ensure_process() + request_queue = self._request_queue + response_queue = self._response_queue + process = self._process + if request_queue is None or response_queue is None or process is None: + raise RuntimeError("OCR runner failed to initialize") + request_queue.put({"page": page, "image_path": image_path}) + deadline = time.monotonic() + timeout + while True: + remaining = deadline - time.monotonic() + if remaining <= 0: + self._terminate_process() + raise TimeoutException( + internal_message=( + f"OCR child timed out after {timeout}s: page={page}, " + f"pid={process.pid}" + ), + retry_after=30, + ) + try: + result = response_queue.get( + timeout=min(remaining, 0.1) + ) + break + except queue_module.Empty: + if process.is_alive(): + continue + self._terminate_process() + raise PDFParsingException( + user_message="Failed to process your document. Please try again.", + reason="SUBPROCESS_CRASH", + internal_message=( + f"OCR child exited without a result: page={page}, " + f"pid={process.pid}" + ), + ) + if not process.is_alive() and not result: + self._terminate_process() + raise PDFParsingException( + user_message="Failed to process your document. Please try again.", + reason="SUBPROCESS_CRASH", + internal_message=f"OCR child exited without a result: page={page}", + ) + if not result.get("ok"): + raise PDFParsingException( + user_message="Failed to process your document. Please try again.", + reason="SUBPROCESS_FAILED", + internal_message=( + f"OCR child failed on page {page}: " + f"{result.get('error_type')}: {result.get('error_msg')}" + ), + ) + return result + + def _ensure_process(self) -> None: + if self._process is not None and self._process.is_alive(): + return + self.close() + self._request_queue = OCR_RUNNER_CONTEXT.Queue() + self._response_queue = OCR_RUNNER_CONTEXT.Queue() + self._process = OCR_RUNNER_CONTEXT.Process( + target=_run_ocr_process, + args=(self._request_queue, self._response_queue), + ) + self._process.start() + logger.info("[ocr-runner] started persistent OCR child pid={}", self._process.pid) + + def _terminate_process(self) -> None: + process = self._process + self._process = None + if process is not None and process.is_alive(): + process.kill() + process.join(timeout=5) + + +_OCR_RUNNER = _OcrRunner() +atexit.register(_OCR_RUNNER.close) def _line_text(item: Any) -> str: @@ -36,25 +209,6 @@ def _line_score(item: Any) -> float: return 0.0 -@worker -def _run_ocr_worker(queue: Any, page: int, image_path: str) -> None: - """Run the local OCR model outside the heartbeat-bearing worker process.""" - from rapidocr_onnxruntime import RapidOCR - - engine = RapidOCR(intra_op_num_threads=1, inter_op_num_threads=1) - lines: list[dict[str, Any]] = [] - result, _elapse = engine(image_path) - for item in result or []: - lines.append( - { - "box": _line_box(item), - "text": _line_text(item), - "score": _line_score(item), - } - ) - queue.put({"ok": True, "page": page, "lines": lines}) - - @register_tool( name="ocr.pages", description="Run RapidOCR on specified pages and return positioned text lines.", @@ -99,7 +253,11 @@ def ocr_pages(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: if not image_path: page_lines[page] = [] continue - result = run_in_child_process(_run_ocr_worker, page, image_path, timeout=300) + result = _OCR_RUNNER.run_page( + page, + image_path, + timeout=OCR_TIMEOUT_SECONDS, + ) result_page = int(result.get("page") or page) page_lines[result_page] = list(result.get("lines") or []) page_texts: dict[int, str] = {} diff --git a/apps/worker/tests/contract/test_ocr_pages_contract.py b/apps/worker/tests/contract/test_ocr_pages_contract.py index c84197ee..1aadbee2 100644 --- a/apps/worker/tests/contract/test_ocr_pages_contract.py +++ b/apps/worker/tests/contract/test_ocr_pages_contract.py @@ -58,27 +58,27 @@ def fake_render(*_args, **_kwargs): calls: list[tuple[int, str, int]] = [] - def fake_child(worker_fn, page, image_path, *, timeout): - assert worker_fn.__name__ == "_run_ocr_worker" - calls.append((page, image_path, timeout)) - assert page == 1 - assert image_path == "/tmp/ocr_page_1.png" - assert timeout == 300 - return { - "ok": True, - "page": page, - "lines": [ - { - "box": [[0, 0], [1, 0], [1, 1], [0, 1]], - "text": "Hello", - "score": 0.9, - } - ], - } + class FakeRunner: + def run_page(self, page, image_path, *, timeout): + assert page == 1 + assert image_path == "/tmp/ocr_page_1.png" + calls.append((page, image_path, timeout)) + assert timeout == 300 + return { + "ok": True, + "page": page, + "lines": [ + { + "box": [[0, 0], [1, 0], [1, 1], [0, 1]], + "text": "Hello", + "score": 0.9, + } + ], + } with ( patch.dict(ocr_pages.__globals__, {"render_pages": fake_render}), - patch.dict(ocr_pages.__globals__, {"run_in_child_process": fake_child}), + patch.dict(ocr_pages.__globals__, {"_OCR_RUNNER": FakeRunner()}), ): result = ocr_pages(ctx, {"pages": [1]}) @@ -91,7 +91,7 @@ def fake_child(worker_fn, page, image_path, *, timeout): assert calls == [(1, "/tmp/ocr_page_1.png", 300)] -def test_ocr_pages_runs_one_child_per_page() -> None: +def test_ocr_pages_runs_one_runner_request_per_page() -> None: ctx = _ctx() calls: list[tuple[int, str]] = [] @@ -101,21 +101,15 @@ def fake_render(*_args: object, **_kwargs: object) -> list[dict[str, object]]: {"page": 2, "png_path": "/tmp/ocr_page_2.png"}, ] - def fake_child( - worker_fn: object, - page: int, - image_path: str, - *, - timeout: int, - ) -> dict[str, object]: - assert getattr(worker_fn, "__name__", None) == "_run_ocr_worker" - assert timeout == 300 - calls.append((page, image_path)) - return {"ok": True, "page": page, "lines": []} + class FakeRunner: + def run_page(self, page, image_path, *, timeout): + assert timeout == 300 + calls.append((page, image_path)) + return {"ok": True, "page": page, "lines": []} with ( patch.dict(ocr_pages.__globals__, {"render_pages": fake_render}), - patch.dict(ocr_pages.__globals__, {"run_in_child_process": fake_child}), + patch.dict(ocr_pages.__globals__, {"_OCR_RUNNER": FakeRunner()}), ): result = ocr_pages(ctx, {"pages": [1, 2]}) From f66b061f8aa416089de3bf493466bef2a4dcd83e Mon Sep 17 00:00:00 2001 From: suguanYang Date: Tue, 8 Sep 2026 19:58:08 +0800 Subject: [PATCH 03/15] perf: harden persistent OCR runner --- apps/worker/app/core/worker_bootstrap.py | 8 + .../document_agent/tools/ocr_pages.py | 434 +++++++++++++----- .../tests/contract/test_ocr_pages_contract.py | 6 +- 3 files changed, 331 insertions(+), 117 deletions(-) diff --git a/apps/worker/app/core/worker_bootstrap.py b/apps/worker/app/core/worker_bootstrap.py index 2b99effb..a7bd5247 100644 --- a/apps/worker/app/core/worker_bootstrap.py +++ b/apps/worker/app/core/worker_bootstrap.py @@ -100,6 +100,14 @@ def _ignore_gevent_cancellation( @worker_shutdown.connect def shutdown_worker(**kwargs: object) -> None: """Clean up shared resources on worker shutdown.""" + try: + from app.services.document_agent.tools.ocr_pages import shutdown_ocr_runner + + shutdown_ocr_runner() + logger.info("Worker OCR runner stopped") + except Exception as exc: + logger.warning(f"Worker OCR runner cleanup failed: {exc}") + try: stop_worker_heartbeat() logger.info("Worker heartbeat stopped") diff --git a/apps/worker/app/services/document_agent/tools/ocr_pages.py b/apps/worker/app/services/document_agent/tools/ocr_pages.py index 972f070a..a655b013 100644 --- a/apps/worker/app/services/document_agent/tools/ocr_pages.py +++ b/apps/worker/app/services/document_agent/tools/ocr_pages.py @@ -4,13 +4,11 @@ import atexit import multiprocessing -import queue as queue_module import time -from dataclasses import dataclass +from multiprocessing.connection import Connection from multiprocessing.process import BaseProcess -from multiprocessing.queues import Queue as MultiprocessingQueue from threading import RLock -from typing import Any +from typing import TYPE_CHECKING, Any, NotRequired, TypedDict, cast from loguru import logger @@ -20,52 +18,100 @@ from app.services.document_agent.visual import render_pages from shared.core.exceptions.domain_exceptions import PDFParsingException, TimeoutException +if TYPE_CHECKING: + from gevent.lock import Semaphore + from gevent.threadpool import ThreadPool -OCR_TIMEOUT_SECONDS = 300 + +OCR_TIMEOUT_SECONDS = 1800 +OCR_INTRA_OP_THREADS = 3 +OCR_INTER_OP_THREADS = 1 +OCR_QUEUE_POLL_INTERVAL_SECONDS = 0.1 +OCR_CHILD_JOIN_TIMEOUT_SECONDS = 5 OCR_RUNNER_CONTEXT = multiprocessing.get_context("spawn") -@dataclass(frozen=True) -class _OcrRequestResult: - status: str - result: dict[str, Any] | None = None +class _OcrRequest(TypedDict): + page: int + image_path: str + + +class _OcrResponse(TypedDict): + ok: bool + page: NotRequired[int] + lines: NotRequired[list[dict[str, Any]]] + error_type: NotRequired[str] + error_msg: NotRequired[str] def _run_ocr_process( - request_queue: MultiprocessingQueue, - response_queue: MultiprocessingQueue, + request_connection: Connection, + response_connection: Connection, ) -> None: """Serve sequential OCR requests while keeping one model instance alive.""" - from rapidocr_onnxruntime import RapidOCR - - engine = RapidOCR(intra_op_num_threads=1, inter_op_num_threads=1) - while True: - request = request_queue.get() - if request is None: - return - page = int(request["page"]) - image_path = str(request["image_path"]) - try: - result, _elapse = engine(image_path) - lines: list[dict[str, Any]] = [] - for item in result or []: - lines.append( + try: + from rapidocr_onnxruntime import RapidOCR + + engine = RapidOCR( + intra_op_num_threads=OCR_INTRA_OP_THREADS, + inter_op_num_threads=OCR_INTER_OP_THREADS, + ) + except Exception as exc: + response_connection.send( + { + "ok": False, + "error_type": type(exc).__name__, + "error_msg": str(exc), + } + ) + _close_child_connections(request_connection, response_connection) + return + + try: + while True: + request = request_connection.recv() + if request is None: + return + page = int(request["page"]) + image_path = str(request["image_path"]) + try: + result, _elapse = engine(image_path) + lines: list[dict[str, Any]] = [] + for item in result or []: + lines.append( + { + "box": _line_box(item), + "text": _line_text(item), + "score": _line_score(item), + } + ) + response_connection.send({"ok": True, "page": page, "lines": lines}) + except Exception as exc: + response_connection.send( { - "box": _line_box(item), - "text": _line_text(item), - "score": _line_score(item), + "ok": False, + "page": page, + "error_type": type(exc).__name__, + "error_msg": str(exc), } ) - response_queue.put({"ok": True, "page": page, "lines": lines}) - except Exception as exc: - response_queue.put( - { - "ok": False, - "page": page, - "error_type": type(exc).__name__, - "error_msg": str(exc), - } - ) + finally: + _close_child_connections(request_connection, response_connection) + + +def _close_child_connections( + request_connection: Connection, + response_connection: Connection, +) -> None: + request_connection.close() + response_connection.close() + + +def _close_parent_connection(connection: Connection) -> None: + try: + connection.close() + except Exception: + pass class _OcrRunner: @@ -73,70 +119,135 @@ class _OcrRunner: def __init__(self) -> None: self._process: BaseProcess | None = None - self._request_queue: MultiprocessingQueue | None = None - self._response_queue: MultiprocessingQueue | None = None - self._executor: Any | None = None + self._request_connection: Connection | None = None + self._response_connection: Connection | None = None + self._executor: ThreadPool | None = None + self._slot: Semaphore | None = None self._lock = RLock() - def run_page(self, page: int, image_path: str, *, timeout: int) -> dict[str, Any]: - executor = self._get_executor() - return executor.apply(self._run_page_blocking, (page, image_path, timeout)) + def run_page(self, page: int, image_path: str, *, timeout: int) -> _OcrResponse: + deadline = time.monotonic() + timeout + slot = self._get_slot() + remaining = deadline - time.monotonic() + if remaining <= 0 or not slot.acquire(timeout=remaining): + raise TimeoutException( + internal_message=( + f"OCR request waited more than {timeout}s for the shared runner: " + f"page={page}" + ), + retry_after=30, + ) + + task = None + try: + executor = self._get_executor() + task = executor.spawn( + self._run_page_blocking, + page, + image_path, + deadline, + ) + remaining = deadline - time.monotonic() + if remaining <= 0: + raise TimeoutException( + internal_message=( + f"OCR request timed out before execution: page={page}" + ), + retry_after=30, + ) + raw_result = task.get(timeout=remaining) + if not isinstance(raw_result, dict): + raise PDFParsingException( + user_message="Failed to process your document. Please try again.", + reason="SUBPROCESS_FAILED", + internal_message=f"OCR runner returned an invalid result: page={page}", + ) + return cast(_OcrResponse, raw_result) + except BaseException as exc: + self._cancel_active_process() + if task is not None: + try: + task.get(timeout=OCR_CHILD_JOIN_TIMEOUT_SECONDS) + except BaseException: + pass + from gevent.timeout import Timeout + + if isinstance(exc, Timeout): + raise TimeoutException( + internal_message=( + f"OCR request timed out after {timeout}s: page={page}" + ), + retry_after=30, + ) from exc + raise + finally: + slot.release() def close(self) -> None: + process, request_connection, response_connection = self._detach_process() + self._stop_process(process, request_connection, response_connection) + with self._lock: - process = self._process - request_queue = self._request_queue - response_queue = self._response_queue - self._process = None - self._request_queue = None - self._response_queue = None - if process is not None and process.is_alive() and request_queue is not None: - request_queue.put(None) - process.join(timeout=5) - if process is not None and process.is_alive(): - process.kill() - process.join(timeout=5) - for result_queue in (request_queue, response_queue): - if result_queue is not None: - result_queue.close() - - def _get_executor(self) -> Any: + executor = self._executor + self._executor = None + if executor is not None: + executor.kill() + executor.join() + + def _get_executor(self) -> ThreadPool: if self._executor is None: from gevent.threadpool import ThreadPool self._executor = ThreadPool(maxsize=1) return self._executor - def _run_page_blocking(self, page: int, image_path: str, timeout: int) -> dict[str, Any]: - with self._lock: - self._ensure_process() - request_queue = self._request_queue - response_queue = self._response_queue - process = self._process - if request_queue is None or response_queue is None or process is None: - raise RuntimeError("OCR runner failed to initialize") - request_queue.put({"page": page, "image_path": image_path}) - deadline = time.monotonic() + timeout + def _get_slot(self) -> Semaphore: + if self._slot is None: + from gevent.lock import Semaphore + + self._slot = Semaphore(1) + return self._slot + + def _run_page_blocking( + self, + page: int, + image_path: str, + deadline: float, + ) -> _OcrResponse: + self._ensure_process() + request_connection = self._request_connection + response_connection = self._response_connection + process = self._process + if request_connection is None or response_connection is None or process is None: + raise RuntimeError("OCR runner failed to initialize") + + request: _OcrRequest = {"page": page, "image_path": image_path} + request_connection.send(request) + try: while True: remaining = deadline - time.monotonic() if remaining <= 0: - self._terminate_process() + self._stop_active_process( + process, request_connection, response_connection + ) raise TimeoutException( internal_message=( - f"OCR child timed out after {timeout}s: page={page}, " - f"pid={process.pid}" + f"OCR child timed out after {OCR_TIMEOUT_SECONDS}s: " + f"page={page}, pid={process.pid}" ), retry_after=30, ) try: - result = response_queue.get( - timeout=min(remaining, 0.1) - ) - break - except queue_module.Empty: + if response_connection.poll( + timeout=min(remaining, OCR_QUEUE_POLL_INTERVAL_SECONDS) + ): + result = response_connection.recv() + break if process.is_alive(): continue - self._terminate_process() + self._stop_active_process( + process, request_connection, response_connection + ) raise PDFParsingException( user_message="Failed to process your document. Please try again.", reason="SUBPROCESS_CRASH", @@ -145,49 +256,144 @@ def _run_page_blocking(self, page: int, image_path: str, timeout: int) -> dict[s f"pid={process.pid}" ), ) - if not process.is_alive() and not result: - self._terminate_process() - raise PDFParsingException( - user_message="Failed to process your document. Please try again.", - reason="SUBPROCESS_CRASH", - internal_message=f"OCR child exited without a result: page={page}", - ) - if not result.get("ok"): - raise PDFParsingException( - user_message="Failed to process your document. Please try again.", - reason="SUBPROCESS_FAILED", - internal_message=( - f"OCR child failed on page {page}: " - f"{result.get('error_type')}: {result.get('error_msg')}" - ), - ) - return result + except Exception as exc: + self._stop_active_process( + process, request_connection, response_connection + ) + raise PDFParsingException( + user_message="Failed to process your document. Please try again.", + reason="SUBPROCESS_FAILED", + internal_message=( + f"OCR child response queue failed on page {page}: " + f"{type(exc).__name__}: {exc}" + ), + ) from exc + except BaseException: + raise + + if not isinstance(result, dict): + self._stop_active_process( + process, request_connection, response_connection + ) + raise PDFParsingException( + user_message="Failed to process your document. Please try again.", + reason="SUBPROCESS_FAILED", + internal_message=f"OCR child returned an invalid response: page={page}", + ) + if not result.get("ok"): + error_type = result.get("error_type", "UnknownError") + error_msg = result.get("error_msg", "unknown OCR child failure") + raise PDFParsingException( + user_message="Failed to process your document. Please try again.", + reason="SUBPROCESS_FAILED", + internal_message=( + f"OCR child failed on page {page}: {error_type}: {error_msg}" + ), + ) + return cast(_OcrResponse, result) def _ensure_process(self) -> None: - if self._process is not None and self._process.is_alive(): - return - self.close() - self._request_queue = OCR_RUNNER_CONTEXT.Queue() - self._response_queue = OCR_RUNNER_CONTEXT.Queue() - self._process = OCR_RUNNER_CONTEXT.Process( - target=_run_ocr_process, - args=(self._request_queue, self._response_queue), - ) - self._process.start() - logger.info("[ocr-runner] started persistent OCR child pid={}", self._process.pid) + with self._lock: + if self._process is not None and self._process.is_alive(): + return + process = self._process + request_connection = self._request_connection + response_connection = self._response_connection + self._process = None + self._request_connection = None + self._response_connection = None + self._stop_process(process, request_connection, response_connection) - def _terminate_process(self) -> None: - process = self._process - self._process = None - if process is not None and process.is_alive(): - process.kill() - process.join(timeout=5) + child_request_connection, request_connection = OCR_RUNNER_CONTEXT.Pipe( + duplex=False + ) + response_connection, child_response_connection = OCR_RUNNER_CONTEXT.Pipe( + duplex=False + ) + process = OCR_RUNNER_CONTEXT.Process( + target=_run_ocr_process, + args=(child_request_connection, child_response_connection), + ) + self._request_connection = request_connection + self._response_connection = response_connection + self._process = process + try: + process.start() + except BaseException: + self._process = None + self._request_connection = None + self._response_connection = None + self._stop_process( + process, + request_connection, + response_connection, + child_request_connection, + child_response_connection, + ) + raise + child_request_connection.close() + child_response_connection.close() + logger.info("[ocr-runner] started persistent OCR child pid={}", process.pid) + + def _detach_process( + self, + ) -> tuple[ + BaseProcess | None, + Connection | None, + Connection | None, + ]: + with self._lock: + process = self._process + request_connection = self._request_connection + response_connection = self._response_connection + self._process = None + self._request_connection = None + self._response_connection = None + return process, request_connection, response_connection + + def _cancel_active_process(self) -> None: + process, request_connection, response_connection = self._detach_process() + self._stop_process(process, request_connection, response_connection) + + def _stop_active_process( + self, + process: BaseProcess, + request_connection: Connection, + response_connection: Connection, + ) -> None: + with self._lock: + if self._process is not process: + return + self._process = None + self._request_connection = None + self._response_connection = None + self._stop_process(process, request_connection, response_connection) + + @staticmethod + def _stop_process( + process: BaseProcess | None, + request_connection: Connection | None, + response_connection: Connection | None, + *child_connections: Connection, + ) -> None: + if process is not None and process.pid is not None: + if process.is_alive(): + process.kill() + process.join(timeout=OCR_CHILD_JOIN_TIMEOUT_SECONDS) + for connection in (request_connection, response_connection, *child_connections): + if connection is not None: + _close_parent_connection(connection) _OCR_RUNNER = _OcrRunner() atexit.register(_OCR_RUNNER.close) +def shutdown_ocr_runner() -> None: + """Stop the worker-local OCR runner during Celery shutdown.""" + _OCR_RUNNER.close() + + def _line_text(item: Any) -> str: if isinstance(item, (list, tuple)) and len(item) >= 2: return str(item[1] or "") diff --git a/apps/worker/tests/contract/test_ocr_pages_contract.py b/apps/worker/tests/contract/test_ocr_pages_contract.py index 1aadbee2..0e0b345a 100644 --- a/apps/worker/tests/contract/test_ocr_pages_contract.py +++ b/apps/worker/tests/contract/test_ocr_pages_contract.py @@ -63,7 +63,7 @@ def run_page(self, page, image_path, *, timeout): assert page == 1 assert image_path == "/tmp/ocr_page_1.png" calls.append((page, image_path, timeout)) - assert timeout == 300 + assert timeout == 1800 return { "ok": True, "page": page, @@ -88,7 +88,7 @@ def run_page(self, page, image_path, *, timeout): assert getattr(bands, "header", None) == "" assert getattr(bands, "footer", None) == "" assert result.payload["page_lines"][1][0]["text"] == "Hello" - assert calls == [(1, "/tmp/ocr_page_1.png", 300)] + assert calls == [(1, "/tmp/ocr_page_1.png", 1800)] def test_ocr_pages_runs_one_runner_request_per_page() -> None: @@ -103,7 +103,7 @@ def fake_render(*_args: object, **_kwargs: object) -> list[dict[str, object]]: class FakeRunner: def run_page(self, page, image_path, *, timeout): - assert timeout == 300 + assert timeout == 1800 calls.append((page, image_path)) return {"ok": True, "page": page, "lines": []} From 6a177ed81feced28375a43942ab896ac300d5b57 Mon Sep 17 00:00:00 2001 From: suguanYang Date: Tue, 8 Sep 2026 21:14:01 +0800 Subject: [PATCH 04/15] Potential fix for pull request finding 'CodeQL / Empty except' Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com> --- apps/worker/app/services/document_agent/tools/ocr_pages.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/apps/worker/app/services/document_agent/tools/ocr_pages.py b/apps/worker/app/services/document_agent/tools/ocr_pages.py index a655b013..f2ed76b9 100644 --- a/apps/worker/app/services/document_agent/tools/ocr_pages.py +++ b/apps/worker/app/services/document_agent/tools/ocr_pages.py @@ -110,8 +110,8 @@ def _close_child_connections( def _close_parent_connection(connection: Connection) -> None: try: connection.close() - except Exception: - pass + except Exception as exc: + logger.debug("Ignoring error while closing parent connection: {}", exc) class _OcrRunner: From 47160027b4d32efd7414bc44f7750fef22680911 Mon Sep 17 00:00:00 2001 From: suguanYang Date: Tue, 8 Sep 2026 21:14:15 +0800 Subject: [PATCH 05/15] Potential fix for pull request finding 'CodeQL / Empty except' Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com> --- .../app/services/document_agent/tools/ocr_pages.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/apps/worker/app/services/document_agent/tools/ocr_pages.py b/apps/worker/app/services/document_agent/tools/ocr_pages.py index f2ed76b9..b1a29db4 100644 --- a/apps/worker/app/services/document_agent/tools/ocr_pages.py +++ b/apps/worker/app/services/document_agent/tools/ocr_pages.py @@ -168,8 +168,16 @@ def run_page(self, page: int, image_path: str, *, timeout: int) -> _OcrResponse: if task is not None: try: task.get(timeout=OCR_CHILD_JOIN_TIMEOUT_SECONDS) - except BaseException: - pass + except BaseException as join_exc: + # Best-effort cleanup: preserve the original exception `exc`. + logger.debug( + "Ignoring OCR task join failure during cancellation " + "(page={}, join_timeout={}s): {}: {}", + page, + OCR_CHILD_JOIN_TIMEOUT_SECONDS, + type(join_exc).__name__, + join_exc, + ) from gevent.timeout import Timeout if isinstance(exc, Timeout): From 2addb0d3e6a88e74a9ef0b46e12d16b59bbaba70 Mon Sep 17 00:00:00 2001 From: chengke <404835780@qq.com> Date: Tue, 8 Sep 2026 15:02:34 +0800 Subject: [PATCH 06/15] feat(retrieval): introduce body chunk type constants for asset embedding Added constants for body chunk types that can own Root-parked assets in the serving manifest and navigation modules. Updated relevant logic to utilize these constants for improved clarity and maintainability. Enhanced documentation in the CORPUS_SCHEMA to reflect the ownership rules of body chunks. --- docs/design/entity-node-graph.md | 133 ++++++ .../retrieval/agent_tools/CORPUS_SCHEMA.md | 14 +- .../retrieval/agent_tools/__init__.py | 35 ++ .../retrieval/agent_tools/registry.py | 124 ++++++ .../retrieval/agent_tools/tools/__init__.py | 29 ++ .../retrieval/agent_tools/tools/assets.py | 193 +++++++++ .../retrieval/agent_tools/tools/grep.py | 158 +++++++ .../agent_tools/tools/list_documents.py | 81 ++++ .../retrieval/agent_tools/tools/neighbors.py | 126 ++++++ .../agent_tools/tools/node_filter.py | 198 +++++++++ .../retrieval/agent_tools/tools/outline.py | 155 +++++++ .../retrieval/agent_tools/tools/read.py | 401 ++++++++++++++++++ .../retrieval/agent_tools/tools/recall.py | 250 +++++++++++ .../services/retrieval/nav/nav_knowhere.py | 5 +- .../services/retrieval/serving_manifest.py | 8 +- 15 files changed, 1906 insertions(+), 4 deletions(-) create mode 100644 docs/design/entity-node-graph.md create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/__init__.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/registry.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/__init__.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/assets.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/grep.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/list_documents.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/neighbors.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/outline.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py diff --git a/docs/design/entity-node-graph.md b/docs/design/entity-node-graph.md new file mode 100644 index 00000000..3fe6540a --- /dev/null +++ b/docs/design/entity-node-graph.md @@ -0,0 +1,133 @@ +# Chunk-level entity graph (deferred) + +**Status:** Deferred — not scheduled, no code written. This replaces the +old "entity 节点 / 共现边:schema 文档预留,发布侧不改" non-goal line in +`.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md` §四 with +an actual future phase (see that plan's todo list for the tracking id). + +**Relation to Phase 2 (agent_tools registry)**: does not block or change +it. Reasoning below in "Why this doesn't affect Phase 2." + +## Problem + +Today `DocumentGraphService.publish_document_graph` +(`packages/shared-python/shared/services/retrieval/graph/service.py:70`) +only ever creates **one graph node per document** and only ever creates +**document ↔ document** `related` edges. The entity/keyword overlap that +drives those edges is computed by first collapsing *every chunk in the +document* into one flat entity set +(`get_normalized_entity_set(chunk_metadata_list)`, `service.py:100`) before +any comparison happens — so by the time two documents get connected, you +have already lost which section/chunk in document A actually shares an +entity with which section/chunk in document B. + +The ask: connect the actual **chunks** that share an entity, not just the +two documents they happen to live in. + +## What "node" means here (resolved) + +A chunk is already, in the overwhelming majority of cases, the +bottom-level unit — one leaf section, one body chunk. The one documented +exception (see `CORPUS_SCHEMA.md` §2, and verified against real published +data: 170 of 801 sections in a two-document local corpus) is **`chunk` +track (text-track) only**: a section that has its own content directly +under its heading, before its first child heading, owns a body chunk of +its own even though it also has children. `page_memory` (page) track has +no such exception — only leaves ever own a body chunk there. + +So there is no separate "section-level" option distinct from "chunk-level" +— they are the same thing, because a section owns *at most one* body +chunk. The node for this graph is the chunk: every `text`/`page` body +chunk, and — no reason to special-case them out — every `image`/`table` +chunk too, since they already carry their own `entities` in +`chunk_metadata` independent of which section they are `connect_to`-linked +from. Structural sections that own no chunk of their own simply have no +entities and never become nodes; no rollup needed, no ambiguity. + +**Naming collision to keep in mind when this is built**: the Phase 2 +`node_filter` tool's "node" means a node in the *section/hierarchy tree* +(operates on `section_path` and `summary`, see `CORPUS_SCHEMA.md` §6). The +graph's "node" (`graph_nodes` table) is a completely different structure — +today only `node_kind='document'` rows, this proposal adds +`node_kind='chunk'` rows. Do not conflate the two when writing tool +descriptions or code comments for whichever tool eventually exposes this +graph. + +## Why the DB schema needs no migration + +Verified against the actual model +(`packages/shared-python/shared/models/database/document.py:495-575`): + +- `GraphNode.node_kind` is a plain `String(32)`, not an enum constrained to + `'document'` — a new `'chunk'` value needs no schema change. +- `GraphNode.ref_section_id` already exists as a nullable column + (`document.py:515`) and is already set to `None` for document nodes + (`service.py:137`) — it is unused, not absent. +- `GraphEdge.source_node_id` / `target_node_id` are plain FKs to + `graph_nodes.node_id` (`document.py:546-555`) with no constraint that + both ends share a `node_kind` — a chunk-node ↔ chunk-node edge is already + legal today, mechanically. + +So this is additive: keep the existing `node_kind='document'` nodes/edges +exactly as they are (`neighbors` in Phase 2 keeps querying those, unaffected +— see below), and add `node_kind='chunk'` rows and edges alongside them. + +## What actually needs new design (not just "add a node_kind") + +1. **Stop collapsing to one set per document.** Index each qualifying + chunk's own `entities` (`chunk_metadata.entities`, already extracted per + chunk via `extract_entities_from_chunk_metadata` in + `graph/keywords.py:53`) as its own node, instead of merging via + `get_normalized_entity_set` before any comparison. + +2. **Replace the O(other documents) peer loop with an inverted index.** + `service.py:152-161` currently loads every other `node_kind='document'` + row in the namespace and compares against it — fine at "tens/hundreds + of documents" scale. At chunk scale (tens of thousands of chunks per + namespace) this must become an `entity_key → chunk_node_id` lookup + (a dedicated join table with a plain index beats a JSONB containment + scan at this volume) so a newly published chunk only compares against + chunks that already share at least one entity key, not every chunk in + the namespace. + +3. **Retune the overlap threshold — it does not transfer.** + `graph/keywords.py:7-11`: `MIN_ENTITY_OVERLAP = 2`, + `MIN_SCORE_THRESHOLD = 0.8`, and `compute_entity_score` + (`keywords.py:80-96`) is `weight * shared_weight / min(weight_a, + weight_b)`. This was tuned for whole-document aggregate sets (tens of + entities). A single chunk typically carries 1-3 entities (verified: + one real image chunk had exactly 2). Requiring `≥2` shared entities out + of a 1-3 entity set will rarely fire; and when a tiny set *does* overlap + by even one entity, the length-weighted score can trivially hit 1.0. + Neither behavior is useful. Proposed direction: connect on **≥1** shared + entity, but gate on that entity's **rarity across the namespace** + (inverse document frequency over chunks, not documents) so a common + entity (a year, a generic org name) does not wire every chunk to every + other chunk. This namespace-wide chunk-frequency count does not exist + today (`compute_tfidf_keywords` in `keywords.py:100` only computes + document-frequency *within one document's own chunks*, for its + `top_keywords`, not across the namespace) — it is new infrastructure, + not a reuse of an existing utility. + +4. **Only materialize nodes for chunks that have ≥1 entity.** Chunks with + an empty `entities` list should not get a `graph_nodes` row at all, or + the table balloons with rows that can never have an edge. + +5. **Recommend keeping this additive, not a replacement.** Leave + `node_kind='document'` publication in `publish_document_graph` exactly + as-is; add chunk-level publication as a new, separate write path (can + live in the same service or a sibling one). Lower risk, and the + existing document-level `related` edges stay useful for + `list_documents`/`neighbors`-style "what else is like this document" + overviews that don't need chunk precision. + +## Why this doesn't affect Phase 2 + +Phase 2's tool list (`agent_tools/registry.py` and the 8 tools in +`CORPUS_SCHEMA.md` §6) touches the graph only through `neighbors`, which is +scoped to `node_kind='document'` `related` edges — exactly what exists +today, unchanged by this proposal. `node_filter`, `outline`, `recall`, +`grep`, `read`, `assets`, `list_documents` never touch `graph_nodes` / +`graph_edges` at all. This entity-node-graph work is a later, additive +phase with its own exposure decision (new tool? extend `neighbors` with a +granularity param? not decided — out of scope until this is scheduled). diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/CORPUS_SCHEMA.md b/packages/shared-python/shared/services/retrieval/agent_tools/CORPUS_SCHEMA.md index 496b1607..904d0f5f 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/CORPUS_SCHEMA.md +++ b/packages/shared-python/shared/services/retrieval/agent_tools/CORPUS_SCHEMA.md @@ -54,6 +54,14 @@ they differ in shape, and in **which sections get a body chunk at all**: body chunk. Internal/structural sections never carry a `page` chunk themselves — their summaries aggregate from their leaf descendants. +A section owns **at most one** body chunk either way (verified against +real published data: a section with children and a section without both +had exactly 0 or 1, never more). So a "chunk" and "the section that owns +it" are the same unit, not two different granularities — there is no +separate finer-or-coarser level to choose between. The only structural +sections with no chunk of their own are `chunk`-track sections whose +entire content lives in their descendants. + For `page` chunks specifically: one leaf section's body may span one or more physical pages. A page's text is stored **once**, under whichever leaf is first in reading order to cover that page (the "owner"). Every other @@ -115,7 +123,9 @@ for anything finer-grained than a document pair. ## 5. Reserved / not yet available - **Vector channel**: `recall`'s `channels` parameter reserves a `vector` - option; it does not exist yet. `recall` today is lexical only. + option; it does not exist yet. `recall` today fuses two lexical channels + (`path_content`: persisted map-unit BM25 over path+content; `term`: + substring match over `document_map_units.term_search_text_lower`) via RRF. ## 6. Tools and when to use each @@ -125,7 +135,7 @@ for anything finer-grained than a document pair. | `outline` | The task only needs titles/summaries — overview, "what does chapter N cover," picking where to look before reading | one document, or a `section_path` prefix within it | Titles + summaries + `chunk_count`, no body text, no folding. Depth-limited by argument, not by a token budget. Use this to build your own map instead of relying on a pre-folded one. | | `node_filter` | The task is a traversal/exclusion predicate — FOR ALL / EXISTS / ANY / NOT — over section titles or summaries ("which docs mention X in a heading," "sections NOT about Y") | one or more documents | Deterministic substring/regex match against `section_path` and `summary` only, not body text. Returns the full matching set and count, never a truncated top-K. If the predicate must run against body text, use `grep` instead. | | `grep` | Exact string / regex / identifier / number lookup that must run against body text | scoped by document/section/chunk_type | Returns match count plus snippets, so ANY/ALL logic can also close over body text, not just titles. | -| `recall` | A fuzzy question where you don't know where the answer lives | namespace or scoped | Ranked candidates (path + content BM25 today; term and vector are separate/reserved — see §5) with path and snippet, not full content. | +| `recall` | A fuzzy question where you don't know where the answer lives | namespace or scoped | Ranked candidates from `path_content` (BM25) + `term` (substring) channels fused by RRF; `vector` is reserved — see §5. Returns path and snippet, not full content. | | `read` | You already know which section(s)/chunk(s) to read | one or more sections/chunks | Returns full body content, resolves `SAME-AS` markers into the owner's text, expands `connect_to` assets, and converts `page_assets` into URLs. | | `assets` | You need images/tables directly, or need to find which section(s) host a given asset | one or more documents | Forward (by type/query) and reverse (asset → hosting section) lookup — see §3. | | `neighbors` | You need related documents in the same namespace | one document | Document-level `related` edges only — see §4. | diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py b/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py new file mode 100644 index 00000000..2e228499 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py @@ -0,0 +1,35 @@ +"""Provider-agnostic corpus exploration tools. + +See ``.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md`` (Phase 2) +for the design. Tools in this package query the published, DB-served corpus +described in ``CORPUS_SCHEMA.md`` (``documents`` / ``document_sections`` / +``document_chunks`` / ``graph_nodes`` / ``graph_edges``) — not the on-disk +parse artifacts. + +The same ``REGISTRY`` is meant to be consumed by two harnesses (Phase 3): +the API ``/mcp`` server (Cursor/Codex/Claude) and the in-process +``agent_explore`` tool-loop. Importing ``agent_tools.tools`` registers every +tool as a side effect. +""" + +from __future__ import annotations + +from shared.services.retrieval.agent_tools.registry import ( + REGISTRY, + ToolBudget, + ToolContext, + ToolRegistry, + ToolResult, + ToolSpec, + register_tool, +) + +__all__ = [ + "REGISTRY", + "ToolBudget", + "ToolContext", + "ToolRegistry", + "ToolResult", + "ToolSpec", + "register_tool", +] diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/registry.py b/packages/shared-python/shared/services/retrieval/agent_tools/registry.py new file mode 100644 index 00000000..a4286f52 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/registry.py @@ -0,0 +1,124 @@ +"""Provider-agnostic tool contracts for corpus exploration. + +Mirrors the shape of ``apps/worker/app/services/document_agent/registry.py`` +(``ToolSpec`` + a decorator-based registry), adapted for the async DB-backed +corpus tools in this package: ``ToolSpec(name, description, json_schema, run)``, +``ToolContext(db, user_id, namespace, budget)``, ``ToolResult(text, payload, refs)``. + +Both the API ``/mcp`` server and the in-process ``agent_explore`` tool-loop +(Phase 3) dispatch through the same ``REGISTRY`` — this module has no +provider-specific (MCP / OpenAI tool-calling) concerns. +""" + +from __future__ import annotations + +from collections.abc import Awaitable, Callable +from dataclasses import dataclass, field +from typing import Any + +from sqlalchemy.ext.asyncio import AsyncSession + + +@dataclass(frozen=True) +class ToolBudget: + """Per-call output budget passed down to every tool via ``ToolContext``. + + Tools that return an unbounded/ranked list (``recall``, ``grep``, asset + forward search) truncate to ``max_items`` and note the omission. Tools + that promise a complete, non-truncated set by contract (``node_filter``, + ``outline``) do not apply this budget to their matched-set cardinality — + see ``CORPUS_SCHEMA.md`` §6. + """ + + max_chars: int = 8000 + max_items: int = 50 + + +@dataclass +class ToolContext: + """Per-call execution context. One instance is built per tool dispatch.""" + + db: AsyncSession + user_id: str + namespace: str + budget: ToolBudget = field(default_factory=ToolBudget) + + +@dataclass +class ToolResult: + """Uniform tool output. + + ``text`` is the human/LLM-facing rendering; ``payload`` is the structured + data (for programmatic callers and for building ``refs``); ``refs`` are + resolvable evidence pointers (``{document_id, section_path|chunk_id}``) + that a harness can fold into ``referenced_chunks`` (Phase 3 bridge). + ``error`` is set instead of raising for caller-facing input mistakes (bad + args, unknown document_id) so a tool-loop agent can see and correct them. + """ + + text: str + payload: dict[str, Any] = field(default_factory=dict) + refs: list[dict[str, Any]] = field(default_factory=list) + error: str | None = None + + +ToolHandler = Callable[[ToolContext, dict[str, Any]], Awaitable[ToolResult]] + + +@dataclass(frozen=True) +class ToolSpec: + name: str + description: str + json_schema: dict[str, Any] + run: ToolHandler + + +class ToolRegistry: + """Name -> ``ToolSpec`` map. Provider-agnostic; no MCP/OpenAI coupling.""" + + def __init__(self) -> None: + self._tools: dict[str, ToolSpec] = {} + + def register(self, spec: ToolSpec) -> None: + if spec.name in self._tools: + raise ValueError(f"tool already registered: {spec.name}") + self._tools[spec.name] = spec + + def get(self, name: str) -> ToolSpec | None: + return self._tools.get(name) + + def all(self) -> list[ToolSpec]: + return list(self._tools.values()) + + async def dispatch( + self, name: str, ctx: ToolContext, args: dict[str, Any] + ) -> ToolResult: + spec = self.get(name) + if spec is None: + return ToolResult(text="", error=f"unknown tool: {name}") + return await spec.run(ctx, args) + + +REGISTRY = ToolRegistry() + + +def register_tool( + *, + name: str, + description: str, + json_schema: dict[str, Any], +) -> Callable[[ToolHandler], ToolHandler]: + """Decorator mirroring worker's ``register_tool`` for the async corpus tools.""" + + def _decorator(handler: ToolHandler) -> ToolHandler: + REGISTRY.register( + ToolSpec( + name=name, + description=description, + json_schema=json_schema, + run=handler, + ) + ) + return handler + + return _decorator diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/__init__.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/__init__.py new file mode 100644 index 00000000..f94f447e --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/__init__.py @@ -0,0 +1,29 @@ +"""Importing this package registers every ``corpus.*`` tool into ``REGISTRY``. + +One module per tool, mirroring +``apps/worker/app/services/document_agent/tools/``. +""" + +from __future__ import annotations + +from shared.services.retrieval.agent_tools.tools import ( + assets as _assets, + grep as _grep, + list_documents as _list_documents, + neighbors as _neighbors, + node_filter as _node_filter, + outline as _outline, + read as _read, + recall as _recall, +) + +__all__ = [ + "_assets", + "_grep", + "_list_documents", + "_neighbors", + "_node_filter", + "_outline", + "_read", + "_recall", +] diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/assets.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/assets.py new file mode 100644 index 00000000..18c5a1b6 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/assets.py @@ -0,0 +1,193 @@ +"""``corpus.assets`` — forward asset search and reverse asset -> hosts lookup. + +Image/table chunks are parked under their document's synthetic ``Root`` +section in the DB (§3 of ``CORPUS_SCHEMA.md``); the real association to a +body section lives in ``chunk_metadata.connect_to`` on the *body* chunk, not +on the asset. There is no stored asset -> body back-link, so the reverse +lookup (``host_of``) scans the candidate documents' text/page chunks in +Python and checks ``connect_to`` for the requested target ids. + +``chunk_metadata`` is a plain ``JSON`` column (not ``JSONB``), so a +containment query (``@>``) is not available here — that operator is +JSONB-only in PostgreSQL. +""" + +from __future__ import annotations + +from typing import Any + +from sqlalchemy import select + +from shared.models.database.document import Document, DocumentChunk, DocumentSection +from shared.services.retrieval.agent_tools.registry import ( + ToolContext, + ToolResult, + register_tool, +) +from shared.services.retrieval.hydration.row_utils import iter_connected_target_ids +from shared.services.retrieval.settings import ASSET_CHUNK_TYPES + +_BODY_CHUNK_TYPES = ("text", "page") + + +@register_tool( + name="corpus.assets", + description=( + "Forward search for image/table chunks by type/query, or reverse " + "lookup: given asset chunk_ids (host_of), find which body " + "section(s) embed or reference them via connect_to." + ), + json_schema={ + "type": "object", + "properties": { + "document_ids": {"type": "array", "items": {"type": "string"}}, + "type": { + "type": "string", + "enum": ["image", "table", "any"], + "default": "any", + }, + "query": { + "type": "string", + "description": "Substring match against summary/keywords (forward search only).", + }, + "host_of": { + "type": "array", + "items": {"type": "string"}, + "description": "Asset chunk_ids to reverse-resolve to hosting sections.", + }, + }, + "required": [], + }, +) +async def assets(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: + document_ids = [ + str(d).strip() for d in (args.get("document_ids") or []) if str(d).strip() + ] + host_of = [str(c).strip() for c in (args.get("host_of") or []) if str(c).strip()] + + scope_filters: list[Any] = [ + Document.user_id == ctx.user_id, + Document.namespace == ctx.namespace, + Document.status == "active", + Document.current_job_result_id == DocumentChunk.job_result_id, + ] + if document_ids: + scope_filters.append(Document.document_id.in_(document_ids)) + + if host_of: + return await _reverse_lookup(ctx, scope_filters=scope_filters, target_ids=host_of) + return await _forward_search( + ctx, + scope_filters=scope_filters, + asset_type=str(args.get("type") or "any").strip().lower(), + query=str(args.get("query") or "").strip().lower(), + ) + + +async def _forward_search( + ctx: ToolContext, + *, + scope_filters: list[Any], + asset_type: str, + query: str, +) -> ToolResult: + types = {asset_type} if asset_type in ASSET_CHUNK_TYPES else set(ASSET_CHUNK_TYPES) + stmt = ( + select(DocumentChunk, DocumentSection.section_path, Document.source_file_name) + .select_from(DocumentChunk) + .join(Document, Document.document_id == DocumentChunk.document_id) + .outerjoin(DocumentSection, DocumentSection.section_id == DocumentChunk.section_id) + .where(*scope_filters) + .where(DocumentChunk.chunk_type.in_(sorted(types))) + .order_by(DocumentChunk.document_id, DocumentChunk.sort_order) + ) + rows = (await ctx.db.execute(stmt)).all() + + results: list[dict[str, Any]] = [] + for chunk, section_path, source_file_name in rows: + metadata = chunk.chunk_metadata if isinstance(chunk.chunk_metadata, dict) else {} + summary = str(metadata.get("summary") or "").strip() + keywords = metadata.get("keywords") or [] + if query: + haystack = " ".join( + [summary.lower(), " ".join(str(k).lower() for k in keywords)] + ) + if query not in haystack: + continue + results.append( + { + "chunk_id": chunk.chunk_id, + "document_id": chunk.document_id, + "source_file_name": source_file_name, + "chunk_type": chunk.chunk_type, + "file_path": chunk.file_path, + "summary": summary, + "keywords": keywords, + "section_path": section_path, + } + ) + if len(results) >= ctx.budget.max_items: + break + + lines = [f"assets={len(results)}"] + for r in results: + lines.append(f"- [{r['chunk_type']}] {r['file_path']} — {r['summary']}") + + return ToolResult( + text="\n".join(lines), + payload={"assets": results}, + refs=[{"document_id": r["document_id"], "chunk_id": r["chunk_id"]} for r in results], + ) + + +async def _reverse_lookup( + ctx: ToolContext, + *, + scope_filters: list[Any], + target_ids: list[str], +) -> ToolResult: + target_set = set(target_ids) + stmt = ( + select(DocumentChunk, DocumentSection.section_path, Document.source_file_name) + .select_from(DocumentChunk) + .join(Document, Document.document_id == DocumentChunk.document_id) + .outerjoin(DocumentSection, DocumentSection.section_id == DocumentChunk.section_id) + .where(*scope_filters) + .where(DocumentChunk.chunk_type.in_(_BODY_CHUNK_TYPES)) + ) + rows = (await ctx.db.execute(stmt)).all() + + hosts_by_target: dict[str, list[dict[str, Any]]] = {tid: [] for tid in target_set} + for chunk, section_path, source_file_name in rows: + row = {"chunk_metadata": chunk.chunk_metadata} + for target_id in iter_connected_target_ids(row): + if target_id in target_set: + hosts_by_target[target_id].append( + { + "document_id": chunk.document_id, + "source_file_name": source_file_name, + "section_path": section_path, + "chunk_id": chunk.chunk_id, + "chunk_type": chunk.chunk_type, + } + ) + + lines = [] + for target_id, hosts in hosts_by_target.items(): + if not hosts: + lines.append(f"- {target_id}: no host found (unresolved Root asset)") + continue + for host in hosts: + lines.append( + f"- {target_id} <- {host['source_file_name']} / {host['section_path']}" + ) + + return ToolResult( + text="\n".join(lines) if lines else "no hosts found", + payload={"hosts_by_target": hosts_by_target}, + refs=[ + {"document_id": host["document_id"], "section_path": host["section_path"]} + for hosts in hosts_by_target.values() + for host in hosts + ], + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/grep.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/grep.py new file mode 100644 index 00000000..81bca87e --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/grep.py @@ -0,0 +1,158 @@ +"""``corpus.grep`` — exact string/regex lookup against body text. + +SQL ``ILIKE`` / ``~*`` on ``document_chunks.content``, scoped to the current +revision. Reports a total match count (over the full in-scope corpus, not +just the returned page) alongside capped snippets, so ANY/ALL logic can close +over body text the same way ``corpus.node_filter`` closes over titles/summaries. +""" + +from __future__ import annotations + +import re +from typing import Any + +from sqlalchemy import func, select + +from shared.models.database.document import Document, DocumentChunk, DocumentSection +from shared.services.retrieval.agent_tools.registry import ( + ToolContext, + ToolResult, + register_tool, +) + +_DEFAULT_MAX_RESULTS = 30 +_DEFAULT_CONTEXT_CHARS = 80 + + +def _build_scope_filters( + *, + user_id: str, + namespace: str, + document_ids: list[str], + chunk_types: set[str], +) -> list[Any]: + filters: list[Any] = [ + Document.user_id == user_id, + Document.namespace == namespace, + Document.status == "active", + Document.current_job_result_id == DocumentChunk.job_result_id, + ] + if document_ids: + filters.append(Document.document_id.in_(document_ids)) + if chunk_types: + filters.append(func.lower(DocumentChunk.chunk_type).in_(sorted(chunk_types))) + return filters + + +@register_tool( + name="corpus.grep", + description=( + "Exact string or regex search against chunk body text (content), " + "not titles/summaries (use corpus.node_filter for that). Returns the " + "total number of matching chunks plus a capped list of snippets." + ), + json_schema={ + "type": "object", + "properties": { + "pattern": {"type": "string"}, + "document_ids": {"type": "array", "items": {"type": "string"}}, + "chunk_types": {"type": "array", "items": {"type": "string"}}, + "is_regex": {"type": "boolean", "default": False}, + "context_chars": {"type": "integer", "default": _DEFAULT_CONTEXT_CHARS}, + "max_results": {"type": "integer", "default": _DEFAULT_MAX_RESULTS}, + }, + "required": ["pattern"], + }, +) +async def grep(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: + pattern = str(args.get("pattern") or "").strip() + if not pattern: + return ToolResult(text="", error="grep requires pattern") + is_regex = bool(args.get("is_regex", False)) + context_chars = int(args.get("context_chars") or _DEFAULT_CONTEXT_CHARS) + max_results = int(args.get("max_results") or _DEFAULT_MAX_RESULTS) + document_ids = [ + str(d).strip() for d in (args.get("document_ids") or []) if str(d).strip() + ] + chunk_types = { + str(t).strip().lower() for t in (args.get("chunk_types") or []) if str(t).strip() + } + + if is_regex: + try: + compiled = re.compile(pattern, flags=re.IGNORECASE) + except re.error as exc: + return ToolResult(text="", error=f"invalid regex: {exc}") + else: + compiled = re.compile(re.escape(pattern), flags=re.IGNORECASE) + + filters = _build_scope_filters( + user_id=ctx.user_id, + namespace=ctx.namespace, + document_ids=document_ids, + chunk_types=chunk_types, + ) + content_filter = ( + DocumentChunk.content.op("~*")(pattern) + if is_regex + else DocumentChunk.content.ilike(f"%{pattern}%") + ) + + count_stmt = ( + select(func.count(DocumentChunk.id)) + .select_from(DocumentChunk) + .join(Document, Document.document_id == DocumentChunk.document_id) + .where(*filters, content_filter) + ) + total_matches = int((await ctx.db.execute(count_stmt)).scalar_one()) + + rows_stmt = ( + select( + DocumentChunk.chunk_id, + DocumentChunk.document_id, + DocumentChunk.chunk_type, + DocumentChunk.content, + DocumentSection.section_path, + Document.source_file_name, + ) + .select_from(DocumentChunk) + .join(Document, Document.document_id == DocumentChunk.document_id) + .outerjoin(DocumentSection, DocumentSection.section_id == DocumentChunk.section_id) + .where(*filters, content_filter) + .order_by(DocumentChunk.document_id, DocumentChunk.sort_order) + .limit(max_results) + ) + rows = (await ctx.db.execute(rows_stmt)).all() + + results: list[dict[str, Any]] = [] + for chunk_id, document_id, chunk_type, content, section_path, source_file_name in rows: + text = str(content or "") + match = compiled.search(text) + if match is None: + snippet = text[: context_chars * 2] + else: + start = max(match.start() - context_chars, 0) + end = min(match.end() + context_chars, len(text)) + snippet = text[start:end] + results.append( + { + "document_id": document_id, + "source_file_name": source_file_name, + "chunk_id": chunk_id, + "chunk_type": chunk_type, + "section_path": section_path, + "snippet": snippet, + } + ) + + lines = [f"total_matches={total_matches} returned={len(results)}"] + for r in results: + lines.append(f"- {r['source_file_name']} / {r['section_path']}: {r['snippet']!r}") + + return ToolResult( + text="\n".join(lines), + payload={"total_matches": total_matches, "results": results}, + refs=[ + {"document_id": r["document_id"], "chunk_id": r["chunk_id"]} for r in results + ], + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/list_documents.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/list_documents.py new file mode 100644 index 00000000..d0ddffe1 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/list_documents.py @@ -0,0 +1,81 @@ +"""``corpus.list_documents`` — namespace-level document overview. + +Joins ``documents`` with the document-level ``graph_nodes`` row (§4 of +``CORPUS_SCHEMA.md``) to surface per-document keywords/summary/type-mix +without reading any chunk content. +""" + +from __future__ import annotations + +from typing import Any + +from sqlalchemy import select + +from shared.models.database.document import Document, GraphNode +from shared.services.retrieval.agent_tools.registry import ( + ToolContext, + ToolResult, + register_tool, +) + + +@register_tool( + name="corpus.list_documents", + description=( + "List every active document in the namespace with its parse_track " + "and, when available, document-level graph metadata (top_keywords, " + "top_summary, chunk type mix). Use this to start cold: which " + "documents exist and what are they about, before picking one for " + "outline/node_filter/recall/read." + ), + json_schema={ + "type": "object", + "properties": {}, + "required": [], + }, +) +async def list_documents(ctx: ToolContext, _args: dict[str, Any]) -> ToolResult: + stmt = ( + select(Document, GraphNode.properties) + .outerjoin( + GraphNode, + (GraphNode.owner_document_id == Document.document_id) + & (GraphNode.node_kind == "document"), + ) + .where(Document.user_id == ctx.user_id) + .where(Document.namespace == ctx.namespace) + .where(Document.status == "active") + .order_by(Document.source_file_name) + ) + rows = (await ctx.db.execute(stmt)).all() + + documents: list[dict[str, Any]] = [] + lines: list[str] = [] + for document, properties in rows: + props = properties if isinstance(properties, dict) else {} + entry = { + "document_id": document.document_id, + "source_file_name": document.source_file_name, + "parse_track": document.parse_track, + "top_keywords": props.get("top_keywords") or [], + "top_summary": props.get("top_summary") or "", + "types": props.get("types") or {}, + "chunks_count": props.get("chunks_count"), + } + documents.append(entry) + summary_line = ( + f"- {entry['source_file_name']} ({entry['document_id']}, " + f"track={entry['parse_track']}, chunks={entry['chunks_count']})" + ) + if entry["top_summary"]: + summary_line += f"\n summary: {entry['top_summary']}" + if entry["top_keywords"]: + summary_line += f"\n keywords: {', '.join(entry['top_keywords'])}" + lines.append(summary_line) + + text = f"documents={len(documents)}\n" + "\n".join(lines) if documents else "documents=0" + return ToolResult( + text=text, + payload={"documents": documents}, + refs=[{"document_id": doc["document_id"]} for doc in documents], + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/neighbors.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/neighbors.py new file mode 100644 index 00000000..2da21d68 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/neighbors.py @@ -0,0 +1,126 @@ +"""``corpus.neighbors`` — document-level ``related`` graph edges. + +Document-to-document only (§4 of ``CORPUS_SCHEMA.md``): no section- or +entity-level graph nodes exist yet. Edges are undirected and were written by +``DocumentGraphService.publish_document_graph`` with ``shared_entities`` (typed +entity overlap, preferred) or ``shared_keywords`` (TF-IDF fallback). +""" + +from __future__ import annotations + +from typing import Any + +from sqlalchemy import or_, select + +from shared.models.database.document import Document, GraphEdge, GraphNode +from shared.services.retrieval.agent_tools.registry import ( + ToolContext, + ToolResult, + register_tool, +) + + +@register_tool( + name="corpus.neighbors", + description=( + "Return documents related to the given document via the persisted " + "document graph (typed-entity overlap, falling back to TF-IDF " + "keyword overlap), along with the shared terms that justify each " + "edge. Document-level only — there is no section- or entity-level " + "graph yet." + ), + json_schema={ + "type": "object", + "properties": {"document_id": {"type": "string"}}, + "required": ["document_id"], + }, +) +async def neighbors(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: + document_id = str(args.get("document_id") or "").strip() + if not document_id: + return ToolResult(text="", error="neighbors requires document_id") + + document = ( + await ctx.db.execute( + select(Document) + .where(Document.document_id == document_id) + .where(Document.user_id == ctx.user_id) + .where(Document.namespace == ctx.namespace) + .where(Document.status == "active") + ) + ).scalar_one_or_none() + if document is None: + return ToolResult(text="", error=f"unknown document_id: {document_id}") + + node_id = f"doc:{document_id}" + edges = ( + ( + await ctx.db.execute( + select(GraphEdge) + .where(GraphEdge.user_id == ctx.user_id) + .where(GraphEdge.namespace == ctx.namespace) + .where(GraphEdge.edge_kind == "related") + .where( + or_( + GraphEdge.source_node_id == node_id, + GraphEdge.target_node_id == node_id, + ) + ) + ) + ) + .scalars() + .all() + ) + if not edges: + return ToolResult(text="neighbors=0", payload={"neighbors": []}) + + peer_node_ids = { + edge.target_node_id if edge.source_node_id == node_id else edge.source_node_id + for edge in edges + } + peer_nodes = ( + ( + await ctx.db.execute( + select(GraphNode).where(GraphNode.node_id.in_(peer_node_ids)) + ) + ) + .scalars() + .all() + ) + peer_by_id = {n.node_id: n for n in peer_nodes} + + neighbor_list: list[dict[str, Any]] = [] + for edge in sorted(edges, key=lambda e: -(e.weight or 0.0)): + peer_node_id = ( + edge.target_node_id if edge.source_node_id == node_id else edge.source_node_id + ) + peer = peer_by_id.get(peer_node_id) + if peer is None: + continue + props = edge.properties or {} + peer_props = peer.properties or {} + neighbor_list.append( + { + "document_id": peer.owner_document_id, + "source_file_name": peer_props.get("source_file_name"), + "weight": edge.weight, + "edge_basis": props.get("edge_basis"), + "shared_entities": props.get("shared_entities"), + "shared_keywords": props.get("shared_keywords"), + "connection_count": props.get("connection_count"), + } + ) + + lines = [f"neighbors={len(neighbor_list)}"] + for n in neighbor_list: + shared = n["shared_entities"] or n["shared_keywords"] or [] + lines.append( + f"- {n['source_file_name']} ({n['document_id']}) weight={n['weight']} " + f"basis={n['edge_basis']} shared={shared}" + ) + + return ToolResult( + text="\n".join(lines), + payload={"neighbors": neighbor_list}, + refs=[{"document_id": n["document_id"]} for n in neighbor_list], + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py new file mode 100644 index 00000000..84116afb --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py @@ -0,0 +1,198 @@ +"""``corpus.node_filter`` — deterministic FOR-ALL/EXISTS/ANY/NOT predicate over sections. + +Reuses the exact predicate compile/match semantics from +``nav.nav_node_filter`` (path/summary substring|regex, fields AND together, +terms OR together) — see that module's docstring — but walks +``document_sections`` rows for the requested documents' current revision +instead of the in-memory map-nav tree. No top-K: returns the full matched set +and its count, per ``CORPUS_SCHEMA.md`` §6. +""" + +from __future__ import annotations + +from typing import Any + +from sqlalchemy import select + +from shared.models.database.document import Document, DocumentChunk, DocumentSection +from shared.services.retrieval.agent_tools.registry import ( + ToolContext, + ToolResult, + register_tool, +) +from shared.services.retrieval.nav.nav_node_filter import ( + FieldPredicate, + _compile_predicates, + _node_matches, + field_predicate, +) + + +@register_tool( + name="corpus.node_filter", + description=( + "Deterministic FOR-ALL/EXISTS/ANY/NOT filter over section titles " + "(section_path) and summaries — not body text (use corpus.grep for " + "that). Predicates AND together across fields; terms within one " + "field's 'terms' list OR together. Returns the complete matched set " + "and its count, never a truncated top-K." + ), + json_schema={ + "type": "object", + "properties": { + "document_ids": { + "type": "array", + "items": {"type": "string"}, + "minItems": 1, + }, + "predicates": { + "type": "array", + "items": { + "type": "object", + "properties": { + "field": {"type": "string", "enum": ["path", "summary"]}, + "terms": {"type": "array", "items": {"type": "string"}}, + "match": { + "type": "string", + "enum": ["substring", "regex"], + "default": "substring", + }, + }, + "required": ["field", "terms"], + }, + "minItems": 1, + }, + "chunk_types": { + "type": "array", + "items": {"type": "string"}, + "description": ( + "Narrow matched sections to those owning a body chunk of " + "one of these chunk_type values (e.g. ['page'] to filter " + "to page-track leaves only). Omit for no narrowing." + ), + }, + }, + "required": ["document_ids", "predicates"], + }, +) +async def node_filter(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: + document_ids = [ + str(did).strip() for did in (args.get("document_ids") or []) if str(did).strip() + ] + if not document_ids: + return ToolResult(text="", error="node_filter requires document_ids") + raw_predicates = args.get("predicates") or [] + if not raw_predicates: + return ToolResult(text="", error="node_filter requires predicates") + + predicates: list[FieldPredicate] = [] + for raw in raw_predicates: + try: + predicates.append( + field_predicate( + raw.get("field"), + raw.get("terms") or [], + raw.get("match", "substring"), + ) + ) + except ValueError as exc: + return ToolResult(text="", error=str(exc)) + + compiled, failed = _compile_predicates(predicates) + if failed: + return ToolResult( + text=f"failed_predicates={failed}", + payload={"cardinality": 0, "matched_sections": [], "failed_predicates": failed}, + error="one or more predicates failed to compile", + ) + + documents = ( + ( + await ctx.db.execute( + select(Document) + .where(Document.document_id.in_(document_ids)) + .where(Document.user_id == ctx.user_id) + .where(Document.namespace == ctx.namespace) + .where(Document.status == "active") + ) + ) + .scalars() + .all() + ) + revision_by_doc = { + d.document_id: d.current_job_result_id for d in documents if d.current_job_result_id + } + if not revision_by_doc: + return ToolResult(text="", error="no active documents found for document_ids") + + revision_pairs = list(revision_by_doc.items()) + sections = ( + ( + await ctx.db.execute( + select(DocumentSection).where( + DocumentSection.document_id.in_([d for d, _ in revision_pairs]) + ) + ) + ) + .scalars() + .all() + ) + sections = [ + s for s in sections if revision_by_doc.get(s.document_id) == s.job_result_id + ] + + chunk_types = { + str(t).strip().lower() for t in (args.get("chunk_types") or []) if str(t).strip() + } + if chunk_types: + chunk_rows = await ctx.db.execute( + select(DocumentChunk.section_id, DocumentChunk.chunk_type).where( + DocumentChunk.document_id.in_([d for d, _ in revision_pairs]) + ) + ) + allowed_section_ids = { + str(section_id) + for section_id, chunk_type in chunk_rows.all() + if section_id and str(chunk_type or "").strip().lower() in chunk_types + } + sections = [s for s in sections if s.section_id in allowed_section_ids] + + matched_sections: list[dict[str, Any]] = [] + matched_doc_ids: list[str] = [] + seen_docs: set[str] = set() + for section in sorted(sections, key=lambda s: (s.document_id, s.sort_order)): + values = {"path": section.section_path, "summary": section.summary or ""} + if not _node_matches(values, compiled): + continue + matched_sections.append( + { + "document_id": section.document_id, + "section_id": section.section_id, + "section_path": section.section_path, + "summary": section.summary or "", + } + ) + if section.document_id not in seen_docs: + seen_docs.add(section.document_id) + matched_doc_ids.append(section.document_id) + + header = f"hits={len(matched_sections)}" + lines = [header] + for entry in matched_sections: + block = [entry["section_path"]] + if entry["summary"]: + block.append(f" summary: {entry['summary']}") + lines.append("\n".join(block)) + + return ToolResult( + text="\n".join(lines), + payload={ + "cardinality": len(matched_sections), + "matched_sections": matched_sections, + "matched_document_ids": matched_doc_ids, + }, + refs=[ + {"document_id": entry["document_id"], "section_path": entry["section_path"]} + for entry in matched_sections + ], + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/outline.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/outline.py new file mode 100644 index 00000000..db155d77 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/outline.py @@ -0,0 +1,155 @@ +"""``corpus.outline`` — titles + summaries, no body text, no folding. + +Reads ``document_sections`` (+ a ``document_chunks`` count aggregate) for one +document's current revision, optionally scoped to a ``section_path`` prefix +and depth-limited by the caller's own argument — never by a token budget +(see ``CORPUS_SCHEMA.md`` §6). This queries the live tables directly rather +than the compressed ``RetrievalNamespaceMapSnapshot``/serving-manifest blob: +that snapshot is namespace-wide and decoding it to read one document's +subtree would cost more than this document-scoped, index-backed query. +""" + +from __future__ import annotations + +from typing import Any + +from sqlalchemy import func, select + +from shared.models.database.document import Document, DocumentChunk, DocumentSection +from shared.services.retrieval.agent_tools.registry import ( + ToolContext, + ToolResult, + register_tool, +) +from shared.services.retrieval.search.lexical_text import normalize_section_path + + +@register_tool( + name="corpus.outline", + description=( + "Return the section outline (title + summary + chunk_count) for one " + "document, or the subtree under a section_path prefix, without any " + "body text. Use for overviews, tables of contents, or picking where " + "to look before calling read. Depth is limited by the 'depth' " + "argument only, never truncated by a token budget." + ), + json_schema={ + "type": "object", + "properties": { + "document_id": {"type": "string"}, + "path_prefix": { + "type": "string", + "description": ( + "DB section_path (' / '-joined, e.g. 'Chapter 1 / Section " + "1.1'). Omit or use 'Root' for the whole document." + ), + }, + "depth": { + "type": "integer", + "description": ( + "Max levels below path_prefix (or below the document root " + "when path_prefix is omitted) to include. Omit for the " + "full subtree." + ), + }, + }, + "required": ["document_id"], + }, +) +async def outline(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: + document_id = str(args.get("document_id") or "").strip() + if not document_id: + return ToolResult(text="", error="outline requires document_id") + depth_raw = args.get("depth") + depth = int(depth_raw) if depth_raw is not None else None + if depth is not None and depth < 0: + return ToolResult(text="", error="depth must be >= 0") + raw_prefix = str(args.get("path_prefix") or "").strip() + prefix = normalize_section_path(raw_prefix) if raw_prefix else "Root" + + document = ( + await ctx.db.execute( + select(Document) + .where(Document.document_id == document_id) + .where(Document.user_id == ctx.user_id) + .where(Document.namespace == ctx.namespace) + .where(Document.status == "active") + ) + ).scalar_one_or_none() + if document is None or not document.current_job_result_id: + return ToolResult(text="", error=f"unknown document_id: {document_id}") + job_result_id = document.current_job_result_id + + section_stmt = ( + select(DocumentSection) + .where(DocumentSection.document_id == document_id) + .where(DocumentSection.job_result_id == job_result_id) + .order_by(DocumentSection.sort_order, DocumentSection.section_id) + ) + all_sections = list((await ctx.db.execute(section_stmt)).scalars().all()) + + base_level: int | None = None + if prefix == "Root": + base_level = 0 + scoped = all_sections + else: + prefix_section = next( + (s for s in all_sections if s.section_path == prefix), None + ) + if prefix_section is None: + return ToolResult( + text="", error=f"unknown path_prefix for {document_id}: {prefix}" + ) + base_level = prefix_section.section_level + scoped = [ + s + for s in all_sections + if s.section_path == prefix or s.section_path.startswith(f"{prefix} / ") + ] + + if depth is not None: + scoped = [s for s in scoped if (s.section_level - base_level) <= depth] + + section_ids = [s.section_id for s in scoped] + chunk_counts: dict[str, int] = {} + if section_ids: + count_rows = await ctx.db.execute( + select(DocumentChunk.section_id, func.count(DocumentChunk.id)) + .where(DocumentChunk.document_id == document_id) + .where(DocumentChunk.job_result_id == job_result_id) + .where(DocumentChunk.section_id.in_(section_ids)) + .group_by(DocumentChunk.section_id) + ) + chunk_counts = {str(sid): int(count) for sid, count in count_rows.all()} + + nodes: list[dict[str, Any]] = [] + lines: list[str] = [] + for section in scoped: + relative_depth = section.section_level - base_level + node = { + "section_id": section.section_id, + "section_path": section.section_path, + "section_title": section.section_title, + "section_level": section.section_level, + "relative_depth": relative_depth, + "summary": section.summary or "", + "chunk_count": chunk_counts.get(section.section_id, 0), + } + nodes.append(node) + indent = " " * max(relative_depth, 0) + line = f"{indent}- {node['section_title'] or node['section_path']} (chunks={node['chunk_count']})" + if node["summary"]: + line += f"\n{indent} summary: {node['summary']}" + lines.append(line) + + text = f"document={document.source_file_name} sections={len(nodes)}\n" + "\n".join( + lines + ) + return ToolResult( + text=text, + payload={"document_id": document_id, "sections": nodes}, + refs=[ + {"document_id": document_id, "section_path": node["section_path"]} + for node in nodes + ], + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py new file mode 100644 index 00000000..2b532a3f --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py @@ -0,0 +1,401 @@ +"""``corpus.read`` — full body content for already-located sections/chunks. + +Unlike ``hydration.result_assembly.assemble_retrieval_results`` (which +down-weights ``page`` chunks to their summary — see that module's +``_page_summary``, a deliberate trade-off for the retrieval-answer surface), +``read`` returns the page chunk's full body content, with ``[SAME-AS +p]`` markers resolved to the owner section's text (§2 of +``CORPUS_SCHEMA.md``) rather than stripped or summarized. ``connect_to`` +assets are still inlined via the same placeholder mechanism as retrieval, and +``page_assets``/asset ``file_path`` are converted to URLs via the existing +``enrich_rows_with_retrieval_asset_url``. + +SAME-AS resolution is single-level: the owner chunk's full content is +embedded as-is. If that owner chunk itself still contains an unrelated +SAME-AS marker (a different leaf's page), it is not recursively resolved in +this pass — a disclosed scope limit, not a silent gap (the raw marker stays +visible in the embedded text). +""" + +from __future__ import annotations + +import re +from typing import Any + +from sqlalchemy import or_, select + +from shared.models.database.document import ( + Document, + DocumentChunk, + DocumentSection, +) +from shared.models.database.job_result import JobResult +from shared.services.retrieval.agent_tools.registry import ( + ToolContext, + ToolResult, + register_tool, +) +from shared.services.retrieval.hydration.asset_inline import ( + inline_assets_at_placeholders, +) +from shared.services.retrieval.hydration.assets import ( + enrich_rows_with_retrieval_asset_url, +) +from shared.services.retrieval.hydration.connected import hydrate_connected_target_rows +from shared.services.retrieval.hydration.result_assembly import ( + _compose_table_content, + _compose_text_content, + _connected_display_by_target, + _image_display_content, +) +from shared.services.retrieval.hydration.row_utils import normalize_chunk_type +from shared.services.retrieval.search.lexical_text import ( + normalize_section_path, + section_path_from_chunk_path, +) + +_SAME_AS_MARKER_RE = re.compile(r"\[SAME-AS (.+?) p(\d+)\]") +_BODY_CHUNK_TYPES = ("text", "page") + + +def _compose_page_content( + row: dict[str, Any], rows_by_chunk_id: dict[str, dict[str, Any]] +) -> str: + """Like ``_compose_text_content`` but never downgraded to a summary.""" + base_content = str(row.get("content") or "") + display_by_target = _connected_display_by_target(row, rows_by_chunk_id) + if not display_by_target: + return base_content + metadata = row.get("chunk_metadata") or {} + connections = metadata.get("connect_to") if isinstance(metadata, dict) else None + content, _embedded = inline_assets_at_placeholders( + base_content, + connections=connections if isinstance(connections, list) else [], + display_by_target=display_by_target, + ) + return content + + +async def _resolve_same_as_markers( + db: Any, + rows: list[dict[str, Any]], + *, + revision_by_doc: dict[str, str], + source_file_name_by_doc: dict[str, str], +) -> None: + """Mutate ``page`` rows in place, replacing SAME-AS markers with owner text.""" + matches_by_index: dict[int, list[tuple[str, str]]] = {} + needed: set[tuple[str, str]] = set() + for index, row in enumerate(rows): + if normalize_chunk_type(row.get("chunk_type")) != "page": + continue + content = str(row.get("content") or "") + found = list(_SAME_AS_MARKER_RE.finditer(content)) + if not found: + continue + document_id = str(row.get("document_id") or "") + source_file_name = source_file_name_by_doc.get(document_id) + row_matches: list[tuple[str, str]] = [] + for match in found: + owner_db_path = section_path_from_chunk_path( + match.group(1), source_file_name=source_file_name + ) + needed.add((document_id, owner_db_path)) + row_matches.append((match.group(0), owner_db_path)) + matches_by_index[index] = row_matches + + if not needed: + return + + owner_content: dict[tuple[str, str], str] = {} + for document_id, owner_path in needed: + job_result_id = revision_by_doc.get(document_id) + if not job_result_id: + continue + result = await db.execute( + select(DocumentChunk.content) + .select_from(DocumentChunk) + .join(DocumentSection, DocumentSection.section_id == DocumentChunk.section_id) + .where(DocumentChunk.document_id == document_id) + .where(DocumentChunk.job_result_id == job_result_id) + .where(DocumentSection.section_path == owner_path) + .where(DocumentChunk.chunk_type == "page") + ) + content_row = result.first() + owner_content[(document_id, owner_path)] = ( + str(content_row[0]) if content_row and content_row[0] else "" + ) + + for index, row_matches in matches_by_index.items(): + row = rows[index] + content = str(row.get("content") or "") + document_id = str(row.get("document_id") or "") + for marker_text, owner_path in row_matches: + resolved = owner_content.get((document_id, owner_path), "") + if resolved: + replacement = f"(SAME-AS {owner_path} resolved)\n{resolved}" + else: + replacement = f"(SAME-AS {owner_path} — page not found)" + content = content.replace(marker_text, replacement, 1) + row["content"] = content + + +@register_tool( + name="corpus.read", + description=( + "Read full body content for already-located sections or chunks. " + "Resolves page-track SAME-AS pointers to the owner section's text, " + "inlines connect_to assets, and converts asset/page_assets " + "references to URLs. Use after outline/node_filter/recall/grep " + "have located where to look." + ), + json_schema={ + "type": "object", + "properties": { + "refs": { + "type": "array", + "items": { + "type": "object", + "properties": { + "document_id": {"type": "string"}, + "section_path": {"type": "string"}, + "chunk_id": {"type": "string"}, + }, + "required": ["document_id"], + }, + "minItems": 1, + "description": "Each ref needs document_id and either section_path or chunk_id.", + }, + "mode": { + "type": "string", + "enum": ["self", "descendants"], + "default": "self", + "description": ( + "'descendants' also reads every section under a " + "section_path ref; ignored for chunk_id refs." + ), + }, + "include_assets": {"type": "boolean", "default": True}, + "resolve_same_as": {"type": "boolean", "default": True}, + }, + "required": ["refs"], + }, +) +async def read(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: + refs = args.get("refs") or [] + if not refs: + return ToolResult(text="", error="read requires refs") + mode = str(args.get("mode") or "self").strip().lower() + if mode not in ("self", "descendants"): + return ToolResult(text="", error=f"unsupported mode: {mode}") + include_assets = bool(args.get("include_assets", True)) + resolve_same_as_flag = bool(args.get("resolve_same_as", True)) + + document_ids = { + str(ref.get("document_id") or "").strip() for ref in refs if ref.get("document_id") + } + documents = ( + ( + await ctx.db.execute( + select(Document) + .where(Document.document_id.in_(document_ids)) + .where(Document.user_id == ctx.user_id) + .where(Document.namespace == ctx.namespace) + .where(Document.status == "active") + ) + ) + .scalars() + .all() + ) + revision_by_doc = { + d.document_id: d.current_job_result_id for d in documents if d.current_job_result_id + } + source_file_name_by_doc = {d.document_id: d.source_file_name or "" for d in documents} + job_result_ids = sorted(set(revision_by_doc.values())) + job_id_by_revision: dict[str, str] = {} + if job_result_ids: + job_rows = await ctx.db.execute( + select(JobResult.id, JobResult.job_id).where(JobResult.id.in_(job_result_ids)) + ) + job_id_by_revision = {str(rid): str(jid) for rid, jid in job_rows.all() if rid and jid} + + base_rows: list[dict[str, Any]] = [] + errors: list[str] = [] + for ref in refs: + document_id = str(ref.get("document_id") or "").strip() + job_result_id = revision_by_doc.get(document_id) + if not job_result_id: + errors.append(f"unknown document_id: {document_id}") + continue + chunk_id = str(ref.get("chunk_id") or "").strip() + section_path = str(ref.get("section_path") or "").strip() + source_file_name = source_file_name_by_doc.get(document_id, "") + job_id = job_id_by_revision.get(job_result_id) + + if chunk_id: + row = ( + await ctx.db.execute( + select(DocumentChunk, DocumentSection.section_path) + .select_from(DocumentChunk) + .outerjoin( + DocumentSection, + DocumentSection.section_id == DocumentChunk.section_id, + ) + .where(DocumentChunk.document_id == document_id) + .where(DocumentChunk.job_result_id == job_result_id) + .where(DocumentChunk.chunk_id == chunk_id) + ) + ).first() + if row is None: + errors.append(f"unknown chunk_id: {chunk_id} in {document_id}") + continue + chunk, resolved_section_path = row + base_rows.append( + { + "document_id": document_id, + "job_result_id": job_result_id, + "job_id": job_id, + "source_file_name": source_file_name, + "chunk_id": chunk.chunk_id, + "section_id": chunk.section_id, + "section_path": resolved_section_path, + "chunk_type": chunk.chunk_type, + "content": chunk.content, + "chunk_metadata": chunk.chunk_metadata or {}, + "file_path": chunk.file_path, + } + ) + continue + + if not section_path: + errors.append(f"ref for {document_id} needs section_path or chunk_id") + continue + + normalized = normalize_section_path(section_path) + path_filter = DocumentSection.section_path == normalized + if mode == "descendants": + path_filter = or_( + path_filter, DocumentSection.section_path.like(f"{normalized} / %") + ) + section_rows = ( + ( + await ctx.db.execute( + select(DocumentSection) + .where(DocumentSection.document_id == document_id) + .where(DocumentSection.job_result_id == job_result_id) + .where(path_filter) + .order_by(DocumentSection.sort_order) + ) + ) + .scalars() + .all() + ) + if not section_rows: + errors.append(f"unknown section_path for {document_id}: {normalized}") + continue + section_ids = [s.section_id for s in section_rows] + chunk_rows = ( + await ctx.db.execute( + select(DocumentChunk).where( + DocumentChunk.document_id == document_id, + DocumentChunk.job_result_id == job_result_id, + DocumentChunk.section_id.in_(section_ids), + # Body chunks only (text/page). image/table chunks share a + # section_id with whichever section happens to store them + # in the DB (always Root — CORPUS_SCHEMA.md §3), which is + # not the same as "belonging" to that section; their real + # association is connect_to on the body chunk, resolved + # below via hydrate_connected_target_rows. Without this + # filter, reading Root would return every still-unmounted + # asset in the document as spurious top-level entries. + DocumentChunk.chunk_type.in_(_BODY_CHUNK_TYPES), + ) + ) + ).scalars().all() + section_path_by_id = {s.section_id: s.section_path for s in section_rows} + for chunk in chunk_rows: + base_rows.append( + { + "document_id": document_id, + "job_result_id": job_result_id, + "job_id": job_id, + "source_file_name": source_file_name, + "chunk_id": chunk.chunk_id, + "section_id": chunk.section_id, + "section_path": ( + section_path_by_id.get(chunk.section_id) + if chunk.section_id + else None + ), + "chunk_type": chunk.chunk_type, + "content": chunk.content, + "chunk_metadata": chunk.chunk_metadata or {}, + "file_path": chunk.file_path, + } + ) + + if not base_rows: + return ToolResult( + text="", + error="no chunks resolved for given refs" + (f" ({'; '.join(errors)})" if errors else ""), + ) + + if resolve_same_as_flag: + await _resolve_same_as_markers( + ctx.db, + base_rows, + revision_by_doc=revision_by_doc, + source_file_name_by_doc=source_file_name_by_doc, + ) + + connected_rows: list[dict[str, Any]] = [] + if include_assets: + connected_rows = await hydrate_connected_target_rows( + db=ctx.db, + rows=base_rows, + exclude_document_ids=[], + exclude_sections=[], + ) + rows_by_chunk_id = { + str(row.get("chunk_id") or ""): row + for row in [*base_rows, *connected_rows] + if row.get("chunk_id") + } + + assembled: list[dict[str, Any]] = [] + for row in base_rows: + chunk_type = normalize_chunk_type(row.get("chunk_type")) + composed = dict(row) + if chunk_type == "text": + composed["content"] = _compose_text_content(row, rows_by_chunk_id) if include_assets else row.get("content") + elif chunk_type == "page": + composed["content"] = _compose_page_content(row, rows_by_chunk_id) if include_assets else row.get("content") + elif chunk_type == "table": + composed["content"] = _compose_table_content(row, rows_by_chunk_id) + elif chunk_type == "image": + composed["content"] = _image_display_content(row) + assembled.append(composed) + + if include_assets: + assembled = await enrich_rows_with_retrieval_asset_url( + assembled, log_context="agent_tools.read" + ) + + lines = [] + if errors: + lines.append(f"errors: {'; '.join(errors)}") + for row in assembled: + lines.append( + f"### {row.get('source_file_name')} / {row.get('section_path')} " + f"[{row.get('chunk_type')}]" + ) + lines.append(str(row.get("content") or "")) + + return ToolResult( + text="\n".join(lines), + payload={"chunks": assembled, "errors": errors}, + refs=[ + {"document_id": row["document_id"], "chunk_id": row["chunk_id"]} + for row in assembled + ], + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py new file mode 100644 index 00000000..62b870a2 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py @@ -0,0 +1,250 @@ +"""``corpus.recall`` — fuzzy ranked candidate search. + +Two real channels today, fused by the existing RRF utility +(``search.scoring.merge_channels_rrf``, same ``RRF_K`` as every other RRF +fusion in retrieval): + +- ``path_content``: reuses ``search.map_unit_discovery.map_unit_discovery`` + (persisted map-unit BM25 over path+content, already RRF-fused internally). +- ``term``: a fresh substring channel over + ``document_map_units.term_search_text_lower`` — this column is persisted at + index time but, before this tool, was only read by map_unit_discovery's + *legacy* PG-FTS fallback, never as an independently-ranked channel (see + ``search/map_unit_discovery.py`` module docstring and AGENTS.md Stage ⑤). + +``vector`` is accepted in ``channels`` but rejected as reserved/not +implemented (``CORPUS_SCHEMA.md`` §5) — it is not silently ignored. + +Fusing an already-doubly-fused channel (path_content) with a fresh single +channel (term) at equal RRF weight is a necessary, disclosed design choice: +there is no persisted precedent for a different weight ratio between them +(the old 3-channel weights of path=1.0/content=2.0/term=1.5 no longer exist +in code — only path=1.0/content=2.0 survive in ``nav.knowhere_hybrid``). +""" + +from __future__ import annotations + +from typing import Any + +from sqlalchemy import select, text +from sqlalchemy.ext.asyncio import AsyncSession + +from shared.models.database.document import Document, DocumentChunk +from shared.services.retrieval.agent_tools.registry import ( + ToolContext, + ToolResult, + register_tool, +) +from shared.services.retrieval.search.map_unit_discovery import map_unit_discovery +from shared.services.retrieval.search.scoring import merge_channels_rrf + +_SUPPORTED_CHANNELS = {"path_content", "term"} +_RESERVED_CHANNELS = {"vector"} +_DEFAULT_TOP_K = 20 + +_TERM_CHANNEL_SQL = """ +SELECT dmu.document_id, dmu.job_result_id, dmu.section_id, ds.section_path, + d.source_file_name, dmu.term_search_text_lower +FROM document_map_units dmu +JOIN documents d + ON d.document_id = dmu.document_id + AND d.current_job_result_id = dmu.job_result_id +JOIN document_sections ds ON ds.section_id = dmu.section_id +WHERE d.user_id = :user_id + AND d.namespace = :namespace + AND d.status = 'active' + {doc_clause} + AND dmu.term_search_text_lower LIKE :like_pattern +ORDER BY POSITION(:needle IN dmu.term_search_text_lower) ASC +LIMIT :limit +""" + + +async def _excluded_document_ids( + db: AsyncSession, *, user_id: str, namespace: str, document_ids: list[str] +) -> list[str]: + if not document_ids: + return [] + rows = await db.execute( + select(Document.document_id) + .where(Document.user_id == user_id) + .where(Document.namespace == namespace) + .where(Document.status == "active") + .where(Document.document_id.notin_(document_ids)) + ) + return [str(r[0]) for r in rows.all()] + + +async def _term_channel_rows( + db: AsyncSession, + *, + user_id: str, + namespace: str, + query: str, + document_ids: list[str], + chunk_types: set[str] | None, + top_k: int, +) -> list[dict[str, Any]]: + needle = query.strip().lower() + if not needle: + return [] + params: dict[str, Any] = { + "user_id": user_id, + "namespace": namespace, + "like_pattern": f"%{needle}%", + "needle": needle, + "limit": top_k, + } + doc_clause = "" + if document_ids: + doc_clause = "AND d.document_id = ANY(:doc_ids)" + params["doc_ids"] = document_ids + statement = text(_TERM_CHANNEL_SQL.format(doc_clause=doc_clause)) + unit_rows = [dict(row._mapping) for row in (await db.execute(statement, params)).all()] + if not unit_rows: + return [] + + keys = [ + (row["document_id"], row["job_result_id"], row["section_id"]) for row in unit_rows + ] + chunk_result = await db.execute( + select(DocumentChunk).where( + DocumentChunk.document_id.in_({k[0] for k in keys}), + DocumentChunk.job_result_id.in_({k[1] for k in keys}), + DocumentChunk.section_id.in_({k[2] for k in keys}), + ) + ) + chunk_by_key = { + (c.document_id, c.job_result_id, c.section_id): c + for c in chunk_result.scalars().all() + } + + results: list[dict[str, Any]] = [] + for unit_row in unit_rows: + key = (unit_row["document_id"], unit_row["job_result_id"], unit_row["section_id"]) + chunk = chunk_by_key.get(key) + if chunk is None: + continue + if chunk_types and chunk.chunk_type not in chunk_types: + continue + needle_pos = unit_row["term_search_text_lower"].find(needle) + window_start = max(needle_pos - 80, 0) + window_end = min(needle_pos + len(needle) + 80, len(unit_row["term_search_text_lower"])) + results.append( + { + "chunk_id": chunk.chunk_id, + "document_id": chunk.document_id, + "section_id": chunk.section_id, + "section_path": unit_row["section_path"], + "source_file_name": unit_row["source_file_name"], + "chunk_type": chunk.chunk_type, + "snippet": unit_row["term_search_text_lower"][window_start:window_end], + } + ) + return results + + +@register_tool( + name="corpus.recall", + description=( + "Fuzzy ranked candidate search for a question when you don't know " + "where the answer lives. Fuses a path+content BM25 channel with a " + "term substring channel via RRF. Returns candidates with path and " + "snippet, not full content — call corpus.read on the winners." + ), + json_schema={ + "type": "object", + "properties": { + "query": {"type": "string"}, + "document_ids": {"type": "array", "items": {"type": "string"}}, + "chunk_types": {"type": "array", "items": {"type": "string"}}, + "channels": { + "type": "array", + "items": { + "type": "string", + "enum": ["path_content", "term", "vector"], + }, + "default": ["path_content", "term"], + "description": "'vector' is reserved and not implemented yet.", + }, + "top_k": {"type": "integer", "default": _DEFAULT_TOP_K}, + }, + "required": ["query"], + }, +) +async def recall(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: + query = str(args.get("query") or "").strip() + if not query: + return ToolResult(text="", error="recall requires query") + top_k = int(args.get("top_k") or _DEFAULT_TOP_K) + document_ids = [ + str(d).strip() for d in (args.get("document_ids") or []) if str(d).strip() + ] + chunk_types = { + str(t).strip().lower() for t in (args.get("chunk_types") or []) if str(t).strip() + } or None + requested_channels = set(args.get("channels") or list(_SUPPORTED_CHANNELS)) + reserved_requested = requested_channels & _RESERVED_CHANNELS + active_channels = requested_channels & _SUPPORTED_CHANNELS + unknown_channels = requested_channels - _SUPPORTED_CHANNELS - _RESERVED_CHANNELS + if unknown_channels: + return ToolResult(text="", error=f"unsupported channels: {sorted(unknown_channels)}") + if not active_channels: + return ToolResult( + text="", + error="no runnable channels requested (vector is reserved, not implemented)", + ) + + channel_rows: list[list[dict[str, Any]]] = [] + weights: list[float] = [] + + if "path_content" in active_channels: + exclude_document_ids = await _excluded_document_ids( + ctx.db, user_id=ctx.user_id, namespace=ctx.namespace, document_ids=document_ids + ) + discovery = await map_unit_discovery( + ctx.db, + user_id=ctx.user_id, + namespace=ctx.namespace, + query=query, + top_k=top_k, + exclude_document_ids=exclude_document_ids, + exclude_sections=[], + chunk_types=chunk_types, + ) + channel_rows.append(list(discovery.payload.get("fused_rows") or [])) + weights.append(1.0) + + if "term" in active_channels: + term_rows = await _term_channel_rows( + ctx.db, + user_id=ctx.user_id, + namespace=ctx.namespace, + query=query, + document_ids=document_ids, + chunk_types=chunk_types, + top_k=top_k, + ) + channel_rows.append(term_rows) + weights.append(1.0) + + fused = merge_channels_rrf(channel_rows, weights, top_k) + + lines = [f"candidates={len(fused)}"] + if reserved_requested: + lines.append(f"note: channels {sorted(reserved_requested)} are reserved, not run") + for row in fused: + snippet = str(row.get("content") or row.get("snippet") or "")[:200] + lines.append( + f"- {row.get('source_file_name')} / {row.get('section_path')} " + f"score={row.get('score')}: {snippet!r}" + ) + + return ToolResult( + text="\n".join(lines), + payload={"candidates": fused, "reserved_channels": sorted(reserved_requested)}, + refs=[ + {"document_id": row.get("document_id"), "chunk_id": row.get("chunk_id")} + for row in fused + ], + ) diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_knowhere.py b/packages/shared-python/shared/services/retrieval/nav/nav_knowhere.py index cd569631..bacce7f0 100644 --- a/packages/shared-python/shared/services/retrieval/nav/nav_knowhere.py +++ b/packages/shared-python/shared/services/retrieval/nav/nav_knowhere.py @@ -49,6 +49,9 @@ ) _ASSET_TYPES = ("table", "image") +# Body chunk types that can own a Root-parked asset via connect_to. Both +# chunk-track ("text") and page-track ("page") body chunks can embed assets. +_BODY_CHUNK_TYPES = ("text", "page") # Knowhere sentinel path for the virtual document container (not a collectable leaf). ROOT_SECTION_PATH = "Root" _DEFAULT_DSN = "postgresql://root:root123@127.0.0.1:5433/Knowhere" @@ -736,7 +739,7 @@ def _remount_root_assets(self) -> None: if row is None or is_root_section_path(row.section_path): continue for unit in units: - if unit.chunk_type != "text": + if unit.chunk_type not in _BODY_CHUNK_TYPES: continue for target in _connect_to_targets(unit.metadata or {}): if target in root_assets and target not in owner_by_asset: diff --git a/packages/shared-python/shared/services/retrieval/serving_manifest.py b/packages/shared-python/shared/services/retrieval/serving_manifest.py index 77a33e1c..11b727ee 100644 --- a/packages/shared-python/shared/services/retrieval/serving_manifest.py +++ b/packages/shared-python/shared/services/retrieval/serving_manifest.py @@ -23,6 +23,10 @@ SERVING_MANIFEST_FORMAT_VERSION = 1 NAMESPACE_MAP_SNAPSHOT_FORMAT_VERSION = 2 +# Body chunk types that can own a Root-parked asset via connect_to. Both +# chunk-track ("text") and page-track ("page") body chunks can embed assets. +_BODY_CHUNK_TYPES = {"text", "page"} + def build_revision_serving_payload( db: Session, @@ -66,7 +70,9 @@ def build_revision_serving_payload( } remounted_assets: dict[str, list[str]] = {} for chunk in chunks: - if chunk.chunk_type != "text" or not isinstance(chunk.chunk_metadata, dict): + if chunk.chunk_type not in _BODY_CHUNK_TYPES or not isinstance( + chunk.chunk_metadata, dict + ): continue connections = chunk.chunk_metadata.get("connect_to") if not isinstance(connections, list): From 38ecbe759495a180267b9e325da0b4edd4cb2bf3 Mon Sep 17 00:00:00 2001 From: chengke <404835780@qq.com> Date: Tue, 8 Sep 2026 16:42:01 +0800 Subject: [PATCH 07/15] feat(retrieval): enhance retrieval server and agent tools Updated the README to reflect the new Knowhere 2.0 branding. Enhanced the retrieval server by integrating corpus tools for improved functionality and backward compatibility. Introduced a character budget for evidence text across various tools, ensuring consistent output limits. Refactored agent tools to utilize shared snippet building logic, improving code maintainability and reducing duplication. Added support for a new agentic routing mechanism to facilitate exploration through the agent_explore path. --- README.md | 2 +- apps/api/app/mcp/dynamic_tools.py | 80 +++++ apps/api/app/mcp/retrieval_server.py | 12 +- docs/assets/knowhere-banner-2.0.png | Bin 0 -> 187094 bytes .../retrieval/agent_explore/__init__.py | 25 ++ .../retrieval/agent_explore/bridge.py | 52 +++ .../retrieval/agent_explore/budget.py | 80 +++++ .../retrieval/agent_explore/config.py | 98 ++++++ .../retrieval/agent_explore/episode.py | 311 ++++++++++++++++++ .../retrieval/agent_explore/ref_resolution.py | 94 ++++++ .../services/retrieval/agent_explore/types.py | 32 ++ .../retrieval/agent_tools/__init__.py | 4 + .../retrieval/agent_tools/registry.py | 30 +- .../retrieval/agent_tools/schema_doc.py | 21 ++ .../services/retrieval/agent_tools/snippet.py | 72 ++++ .../retrieval/agent_tools/tools/grep.py | 26 +- .../agent_tools/tools/node_filter.py | 3 +- .../retrieval/agent_tools/tools/read.py | 29 +- .../retrieval/agent_tools/tools/recall.py | 24 +- .../services/retrieval/execution/routes.py | 132 +++++++- .../shared/services/retrieval/nav_config.py | 3 +- .../shared/services/retrieval/settings.py | 5 + 22 files changed, 1083 insertions(+), 52 deletions(-) create mode 100644 apps/api/app/mcp/dynamic_tools.py create mode 100644 docs/assets/knowhere-banner-2.0.png create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/__init__.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/bridge.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/budget.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/config.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/episode.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/ref_resolution.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/types.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/schema_doc.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/snippet.py diff --git a/README.md b/README.md index 8f0178ca..1b961d4f 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -20260506-102713 +Knowhere 2.0

Prepare unstructured data for AI Agents

diff --git a/apps/api/app/mcp/dynamic_tools.py b/apps/api/app/mcp/dynamic_tools.py new file mode 100644 index 00000000..3a52b2fb --- /dev/null +++ b/apps/api/app/mcp/dynamic_tools.py @@ -0,0 +1,80 @@ +"""Bridge ``shared.services.retrieval.agent_tools.REGISTRY`` onto FastMCP. + +FastMCP's public registration API (``FastMCP.tool`` / ``ToolManager.add_tool``) +only builds a tool's schema by introspecting a Python function's *signature* +(``mcp.server.fastmcp.tools.base.Tool.from_function`` -> ``func_metadata``); +there is no public entry point to register a tool from an already-built JSON +Schema dict, which is what every ``agent_tools.ToolSpec`` carries. Since our +schema is the one already shipped to ``agent_explore`` and meant to be +verbatim-identical across harnesses (see ``CORPUS_SCHEMA.md``), we construct +``Tool`` objects directly instead of round-tripping through a synthetic +Python function signature, and insert them into the tool manager's registry +dict — the same dict ``ToolManager.__init__`` accepts a ``tools=`` list for, +just with no public single-tool equivalent of that constructor path. +""" + +from __future__ import annotations + +from typing import Any, AsyncContextManager, Callable + +from mcp.server.fastmcp import Context, FastMCP +from mcp.server.fastmcp.tools.base import Tool +from mcp.server.fastmcp.utilities.func_metadata import ArgModelBase, FuncMetadata +from pydantic import create_model +from sqlalchemy.ext.asyncio import AsyncSession + +from shared.services.retrieval.agent_tools import REGISTRY, ToolContext, ToolSpec +from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 + +DbFactory = Callable[[], AsyncContextManager[AsyncSession]] + + +def _lenient_arg_model(spec: ToolSpec) -> type[ArgModelBase]: + """Build a permissive pydantic arg model for FastMCP's internal validation. + + The schema actually exposed to MCP clients is ``spec.json_schema`` + (``Tool.parameters``, returned verbatim in ``tools/list`` — see + ``FastMCP.list_tools``); this model only has to satisfy + ``FuncMetadata.call_fn_with_arg_validation`` well enough to forward + whatever the client sent through to ``_dispatch_tool``'s ``**kwargs``. + Every property is optional/``Any`` — each tool already validates its own + required args and reports a caller-facing ``ToolResult.error`` for a + missing one, so duplicating "required" enforcement here would just + produce a less informative MCP-level error instead. + """ + properties = spec.json_schema.get("properties", {}) + fields: dict[str, Any] = {key: (Any, None) for key in properties} + return create_model(f"{spec.name.replace('.', '_')}_Args", __base__=ArgModelBase, **fields) + + +def _make_tool(spec: ToolSpec, *, db_factory: DbFactory) -> Tool: + async def _dispatch_tool( + ctx: Context | None = None, **kwargs: Any + ) -> dict[str, Any]: + from app.mcp.retrieval_server import resolve_mcp_namespace, resolve_mcp_user_id + + namespace = resolve_mcp_namespace(ctx=ctx) + async with db_factory() as db: + user_id = await resolve_mcp_user_id(ctx=ctx, db=db) + tool_ctx = ToolContext(db=db, user_id=user_id, namespace=namespace) + result = await REGISTRY.dispatch(spec.name, tool_ctx, kwargs) + return {"text": result.text, "payload": result.payload, "refs": result.refs, "error": result.error} + + return Tool( + fn=_dispatch_tool, + name=spec.name, + title=None, + description=spec.description, + parameters=spec.json_schema, + fn_metadata=FuncMetadata(arg_model=_lenient_arg_model(spec)), + is_async=True, + context_kwarg="ctx", + annotations=None, + ) + + +def register_corpus_tools(server: FastMCP, *, db_factory: DbFactory) -> None: + """Register every ``agent_tools.REGISTRY`` tool onto ``server``.""" + for spec in REGISTRY.all(): + tool = _make_tool(spec, db_factory=db_factory) + server._tool_manager._tools[tool.name] = tool diff --git a/apps/api/app/mcp/retrieval_server.py b/apps/api/app/mcp/retrieval_server.py index 81210b86..89845b64 100644 --- a/apps/api/app/mcp/retrieval_server.py +++ b/apps/api/app/mcp/retrieval_server.py @@ -10,8 +10,10 @@ from pydantic import Field from sqlalchemy.ext.asyncio import AsyncSession +from app.mcp.dynamic_tools import register_corpus_tools from shared.core.database import get_db_context from shared.models.schemas.retrieval_namespace import normalize_retrieval_namespace +from shared.services.retrieval.agent_tools import load_corpus_schema_text from shared.services.retrieval.app_service import run_retrieval_query from shared.services.retrieval.settings import DEFAULT_TOP_K @@ -85,16 +87,16 @@ def create_retrieval_mcp_server( server = FastMCP( "knowhere-retrieval", instructions=( - "Use this server to search published documents. " - "It returns evidence_text (hierarchical evidence tree), " - "referenced_chunks (structured chunk citations), and " - "decision_trace (navigation decisions). " - "Downstream agents should synthesize answers from evidence_text." + "retrieval.query is a one-shot legacy search tool retained for " + "backward compatibility (see its own tool description below). " + "Prefer the corpus.* tools for exploration; the schema below " + "describes what they operate on.\n\n" + load_corpus_schema_text() ), streamable_http_path=streamable_http_path, stateless_http=True, transport_security=create_public_mcp_transport_security(), ) + register_corpus_tools(server, db_factory=db_factory) @server.tool( name="retrieval.query", diff --git a/docs/assets/knowhere-banner-2.0.png b/docs/assets/knowhere-banner-2.0.png new file mode 100644 index 0000000000000000000000000000000000000000..6332a6eeee9fc9e93731627ae55b96399d1da309 GIT binary patch literal 187094 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

0M201kgYqczfX7n8`5Ne2^#3fa{ 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

F!EpyX{(2cvUq$-e|ge9W{pJ=qmi8>OE-LgDr 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 literal 0 HcmV?d00001 diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py b/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py new file mode 100644 index 00000000..f08306a7 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py @@ -0,0 +1,25 @@ +"""In-process tool-calling agentic retrieval route. + +See ``.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md`` +(Phase 3) for the design. Runs the ``agent_tools`` corpus registry through an +LLM tool-calling loop instead of map-nav's PLANNER/HARVEST/CONTROL episode. +Selected via ``RETRIEVAL_AGENTIC_ROUTER=agent_explore`` +(``execution/routes.py``); ``mapnav`` remains the default until this route +passes its Phase 4 evaluation gate. + +No runtime dependency on ``shared.services.retrieval.nav`` — see +``config.py``'s module docstring. +""" + +from __future__ import annotations + +from shared.services.retrieval.agent_explore.budget import EpisodeBudget +from shared.services.retrieval.agent_explore.episode import run_agent_explore_episode +from shared.services.retrieval.agent_explore.types import AgentStep, EpisodeResult + +__all__ = [ + "AgentStep", + "EpisodeBudget", + "EpisodeResult", + "run_agent_explore_episode", +] diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/bridge.py b/packages/shared-python/shared/services/retrieval/agent_explore/bridge.py new file mode 100644 index 00000000..8b114ed9 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/bridge.py @@ -0,0 +1,52 @@ +"""Bridge from an ``agent_explore`` episode to the existing decision-trace shape. + +``DecisionTraceStep`` / ``TraceRecorder`` (``shared/services/retrieval/trace/``) +are already provider-agnostic — this module only maps this package's own +``AgentStep`` records onto that shared shape, mirroring what +``trace/mapnav.py`` does for the map-nav episode object, without importing +anything from ``nav/``. +""" + +from __future__ import annotations + +from shared.services.retrieval.agent_explore.types import AgentStep +from shared.services.retrieval.trace import DecisionTraceStep + +# Mirrors nav_config.MAPNAV_TRACE_RAW_CHARS's existing practice of capping +# raw trace text before it goes into the public decision_trace response — +# redeclared locally (not imported) to keep this package decoupled from +# nav_config.py per config.py's module docstring. +TRACE_OBSERVATION_MAX_CHARS = 2_000 + + +def build_decision_trace(steps: list[AgentStep]) -> list[DecisionTraceStep]: + trace_steps: list[DecisionTraceStep] = [] + for step in steps: + observation_text = step.observation_text + if len(observation_text) > TRACE_OBSERVATION_MAX_CHARS: + observation_text = observation_text[:TRACE_OBSERVATION_MAX_CHARS] + "..." + phase = "finish" if step.tool_name == "finish" else ( + "stop" if not step.tool_name else "tool_call" + ) + trace_steps.append( + DecisionTraceStep( + step_index=step.step_index, + agent="agent_explore", + phase=phase, + observation={"observation_text": observation_text}, + decision={ + "action": step.tool_name or "no_tool_call", + "args": step.tool_args, + }, + result={ + "status": "error" if step.error else "ok", + "error": step.error, + }, + budget={ + "tokens_used_delta": step.tokens_used_delta, + "tokens_used_total": step.tokens_used_total, + }, + elapsed_ms=step.elapsed_ms, + ) + ) + return trace_steps diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/budget.py b/packages/shared-python/shared/services/retrieval/agent_explore/budget.py new file mode 100644 index 00000000..47a0c606 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/budget.py @@ -0,0 +1,80 @@ +"""Per-episode budget enforcement for ``agent_explore``. + +Standalone from ``nav/nav_token_budget.py`` on purpose — this package must +have no runtime dependency on ``nav/`` (see ``config.py``'s module +docstring). Re-reads the same ``RETRIEVAL_NAV_TOKEN_LIMIT`` env var the plan +calls for, so operators keep one token-limit knob across both agentic +routes, but the counting mechanism is a fresh, request-scoped object (this +episode runs as one async function, not a separate thread with recursive +calls), not the nav contextvar machinery ``nav_token_budget`` needed for its +own call shape. +""" + +from __future__ import annotations + +import os +import time +from dataclasses import dataclass, field +from typing import Any + +from shared.services.retrieval.agent_explore.config import ( + AGENT_EXPLORE_MAX_STEPS, + AGENT_EXPLORE_WALL_CLOCK_SECONDS, +) + +_ENV_TOKEN_LIMIT = "RETRIEVAL_NAV_TOKEN_LIMIT" +_DEFAULT_TOKEN_LIMIT = 100_000 + +StopReason = str # one of: "token_limit" | "max_steps" | "wall_clock" + + +def resolve_token_limit() -> int: + """Always a positive limit: env override, else the shared default.""" + try: + limit = int(os.environ.get(_ENV_TOKEN_LIMIT, "").strip()) + except ValueError: + limit = 0 + return limit if limit > 0 else _DEFAULT_TOKEN_LIMIT + + +@dataclass +class EpisodeBudget: + """Tracks one episode's LLM-token / step / wall-clock spend.""" + + token_limit: int = field(default_factory=resolve_token_limit) + max_steps: int = AGENT_EXPLORE_MAX_STEPS + wall_clock_seconds: float = AGENT_EXPLORE_WALL_CLOCK_SECONDS + tokens_used: int = 0 + steps_used: int = 0 + _started_at: float = field(default_factory=time.monotonic, repr=False) + + def record_usage(self, usage: dict[str, Any] | None) -> None: + try: + add = int((usage or {}).get("total_tokens", 0) or 0) + except (TypeError, ValueError): + add = 0 + if add > 0: + self.tokens_used += add + + def record_step(self) -> None: + self.steps_used += 1 + + def exhausted(self) -> StopReason | None: + """Return which budget dimension is exceeded, if any, else None.""" + if self.tokens_used >= self.token_limit: + return "token_limit" + if self.steps_used >= self.max_steps: + return "max_steps" + if time.monotonic() - self._started_at >= self.wall_clock_seconds: + return "wall_clock" + return None + + def snapshot(self) -> dict[str, Any]: + return { + "token_limit": self.token_limit, + "tokens_used": self.tokens_used, + "max_steps": self.max_steps, + "steps_used": self.steps_used, + "wall_clock_seconds": self.wall_clock_seconds, + "elapsed_seconds": round(time.monotonic() - self._started_at, 3), + } diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/config.py b/packages/shared-python/shared/services/retrieval/agent_explore/config.py new file mode 100644 index 00000000..a4d0cec1 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/config.py @@ -0,0 +1,98 @@ +"""Production config for the ``agent_explore`` in-process tool-loop. + +Deliberately independent from ``nav_config.py`` / ``nav/`` — see +``nav_config.py``'s "not read by agent_explore" note. This package must have +no runtime import from ``nav/`` so Phase 5 can delete that package once +``agent_explore`` passes its Phase 4 evaluation gate, without having to first +extract anything out of ``nav/`` for this package to keep working. + +Model choice: reuses the same literal model name as ``nav_config.MAPNAV_MODEL`` +(``deepseek-v4-flash``) — not by importing that module, but as its own +constant — because tool-calling (single, parallel, and forced ``tool_choice``) +was verified live against this exact model during Phase 3 design; no other +model has been verified for this codebase's OpenAI-compatible client. + +``AGENT_EXPLORE_MAX_STEPS`` / ``AGENT_EXPLORE_WALL_CLOCK_SECONDS`` are new +product constants (not specified by the plan text, which only named the two +budget *dimensions* to add). Disclosed here rather than buried: revisit in +Phase 4 evaluation once real latency data exists. +""" + +from __future__ import annotations + +AGENT_EXPLORE_MODEL = "deepseek-v4-flash" + +# One LLM turn = one round-trip that may contain several parallel tool calls +# (see episode.py). Kept low relative to map-nav's per-node dispatch depth +# (≤5) because each turn here can already resolve several tools at once. +AGENT_EXPLORE_MAX_STEPS = 12 + +# Wall-clock ceiling for the whole episode (LLM round-trips + tool +# dispatch), independent of the token budget. New constant, not tuned yet. +AGENT_EXPLORE_WALL_CLOCK_SECONDS = 180.0 + +# Max tokens requested per LLM completion turn (thinking disabled — see +# episode.py; this is completion budget, not context window). +AGENT_EXPLORE_MAX_COMPLETION_TOKENS = 1024 + +FINISH_TOOL_NAME = "finish" + +FINISH_TOOL_SCHEMA: dict[str, object] = { + "type": "object", + "properties": { + "refs": { + "type": "array", + "description": ( + "Final cited evidence, in priority order. Each item " + "identifies one section or chunk you have already looked at " + "via corpus.read (or, for an asset, corpus.assets)." + ), + "items": { + "type": "object", + "properties": { + "document_id": {"type": "string"}, + "section_path": {"type": "string"}, + "chunk_id": {"type": "string"}, + }, + "required": ["document_id"], + }, + }, + "notes": { + "type": "string", + "description": ( + "Optional short note on why these refs answer the query, " + "or why none were found." + ), + }, + }, + "required": ["refs"], +} + +FINISH_TOOL_DESCRIPTION = ( + "Call this when you have gathered enough evidence to answer the query, " + "or when you are certain the corpus does not contain an answer. This " + "ends the exploration — do not answer in plain text; the final answer " + "is synthesized downstream from the refs you cite here." +) + +# Appended after the verbatim CORPUS_SCHEMA.md text (schema_doc.py) to form +# this harness's system prompt. Kept out of CORPUS_SCHEMA.md itself because +# the finish-tool loop contract is agent_explore-specific, not something the +# MCP-facing harnesses (Cursor/Codex/Claude) need — see that file's own +# "single source... do not duplicate" header. +LOOP_CONTRACT_SUFFIX = f""" + +--- + +## Exploration loop contract + +You are exploring this corpus autonomously to answer one query. Use the +tools above to navigate; you may call several tools in one turn when they +are independent. When you have enough evidence, call `{FINISH_TOOL_NAME}` +with the `refs` you want cited as the answer — do not write the final answer +as plain text yourself, it is synthesized downstream from your cited refs. +If you exhaust your tool budget without a confident answer, call +`{FINISH_TOOL_NAME}` with your best-effort `refs` (or an empty list plus a +`notes` explanation of why nothing was found) rather than continuing to +call other tools. +""" diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/episode.py b/packages/shared-python/shared/services/retrieval/agent_explore/episode.py new file mode 100644 index 00000000..fe1ae0de --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/episode.py @@ -0,0 +1,311 @@ +"""In-process tool-calling episode over the ``agent_tools`` corpus registry. + +Uses ``OpenAICompatibleClientSync.chat_completion_raw_with_usage`` — the RAW +response, not ``chat_completion_with_usage`` — because the latter only +returns ``.content`` and silently drops ``message.tool_calls``. Verified live +(2026-09-08) against ``deepseek-v4-flash`` via this codebase's client: +single tool call, parallel tool calls in one turn, tool-result feedback + +final synthesis, and forced ``tool_choice`` (used for the budget-exhaustion +cutoff below) all work. + +Tool calls within one turn are dispatched sequentially against the single +shared ``ToolContext.db`` (``AsyncSession``), not via ``asyncio.gather``: +SQLAlchemy's ``AsyncSession`` is not safe for concurrent use from multiple +coroutines. Batching several tool calls into one LLM turn already removes +the LLM round-trip per tool (the dominant cost); true DB-level concurrency +within a turn is not implemented here. + +No import from ``nav/`` or ``nav_config.py`` — see ``config.py``. +""" + +from __future__ import annotations + +import asyncio +import json +import time +from typing import Any + +from sqlalchemy.ext.asyncio import AsyncSession + +from shared.services.retrieval.agent_explore.budget import EpisodeBudget +from shared.services.retrieval.agent_explore.config import ( + AGENT_EXPLORE_MAX_COMPLETION_TOKENS, + AGENT_EXPLORE_MODEL, + FINISH_TOOL_DESCRIPTION, + FINISH_TOOL_NAME, + FINISH_TOOL_SCHEMA, + LOOP_CONTRACT_SUFFIX, +) +from shared.services.retrieval.agent_explore.types import AgentStep, EpisodeResult +from shared.services.retrieval.agent_tools import ( + REGISTRY, + ToolContext, + ToolResult, + load_corpus_schema_text, +) +from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 + + +def _resolve_client_and_model() -> tuple[Any, str]: + """Mirrors ``nav_llm_backend.nav_chat_sync_backend``'s resolve pattern, + pinned to ``AGENT_EXPLORE_MODEL`` instead of ``nav_config.MAPNAV_MODEL``. + """ + from shared.services.ai.llm_overrides import resolve_text + from shared.services.ai.openai_compatible_client_sync import get_openai_client + + requested = AGENT_EXPLORE_MODEL + effective_model, api_key, api_url = resolve_text(requested) + model = effective_model or requested + client = get_openai_client(model=model, api_key=api_key, api_url=api_url) + return client, model + + +def _openai_safe_name(name: str) -> str: + """DeepSeek's (OpenAI-compatible) function-calling API rejects ``.`` in + ``tools[].function.name`` (must match ``^[a-zA-Z0-9_-]+$``, verified + live), but every ``agent_tools`` name is dotted (``corpus.read``) and + that's also what MCP clients see (no such restriction there) — so the + dotted name stays canonical in ``REGISTRY``/MCP, and this harness-local + underscore form exists only for the wire format to this one provider. + """ + return name.replace(".", "_") + + +def _build_openai_tools() -> tuple[list[dict[str, Any]], dict[str, str]]: + """Return ``(tools, name_map)`` where ``name_map`` maps the OpenAI-safe + name back to the canonical ``REGISTRY`` name (``finish`` maps to itself). + """ + name_map: dict[str, str] = {FINISH_TOOL_NAME: FINISH_TOOL_NAME} + tools: list[dict[str, Any]] = [] + for spec in REGISTRY.all(): + safe_name = _openai_safe_name(spec.name) + name_map[safe_name] = spec.name + tools.append( + { + "type": "function", + "function": { + "name": safe_name, + "description": spec.description, + "parameters": spec.json_schema, + }, + } + ) + tools.append( + { + "type": "function", + "function": { + "name": FINISH_TOOL_NAME, + "description": FINISH_TOOL_DESCRIPTION, + "parameters": FINISH_TOOL_SCHEMA, + }, + } + ) + return tools, name_map + + +def _safe_json_loads(raw: str | None) -> dict[str, Any]: + if not raw: + return {} + try: + parsed = json.loads(raw) + except (TypeError, ValueError): + return {} + return parsed if isinstance(parsed, dict) else {} + + +def _normalize_finish_refs(raw: Any) -> list[dict[str, Any]]: + if not isinstance(raw, list): + return [] + normalized: list[dict[str, Any]] = [] + for item in raw: + if isinstance(item, dict) and str(item.get("document_id") or "").strip(): + normalized.append(item) + return normalized + + +def _tool_message_content(result: ToolResult, *, max_chars: int) -> str: + """Cap a tool's rendered text before it enters LLM context. + + Uses ``ToolBudget.max_chars`` (``EVIDENCE_TEXT_CHAR_BUDGET``, aligned with + map-nav evidence packing) so tools like ``read`` can return unbounded body + text while the harness still bounds what the model sees per turn. + """ + if result.error: + return f"error: {result.error}" + text = result.text or "(empty result)" + if len(text) <= max_chars: + return text + omitted = len(text) - max_chars + return ( + text[:max_chars] + + f"\n...[truncated, {omitted} more chars — call corpus.read again " + "with a narrower/more specific ref if you need the rest]" + ) + + +async def run_agent_explore_episode( + *, + db: AsyncSession, + user_id: str, + namespace: str, + query: str, + budget: EpisodeBudget | None = None, +) -> EpisodeResult: + budget = budget or EpisodeBudget() + tool_ctx = ToolContext(db=db, user_id=user_id, namespace=namespace) + client, model = _resolve_client_and_model() + openai_tools, tool_name_map = _build_openai_tools() + + system_prompt = load_corpus_schema_text() + LOOP_CONTRACT_SUFFIX + messages: list[dict[str, Any]] = [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": query}, + ] + + steps: list[AgentStep] = [] + stop_reason = "finished" + result_refs: list[dict[str, Any]] = [] + result_notes = "" + + while True: + forced_reason = budget.exhausted() + tool_choice: Any = "auto" + if forced_reason is not None: + tool_choice = {"type": "function", "function": {"name": FINISH_TOOL_NAME}} + + turn_started = time.perf_counter() + response, usage = await asyncio.to_thread( + client.chat_completion_raw_with_usage, + messages=messages, + model=model, + temperature=0.0, + max_tokens=AGENT_EXPLORE_MAX_COMPLETION_TOKENS, + tools=openai_tools, + tool_choice=tool_choice, + ) + budget.record_usage(usage) + budget.record_step() + turn_elapsed_ms = int((time.perf_counter() - turn_started) * 1000) + turn_tokens = int((usage or {}).get("total_tokens", 0) or 0) + + message = response.choices[0].message + tool_calls = list(message.tool_calls or []) + + if not tool_calls: + stop_reason = f"budget_{forced_reason}" if forced_reason else "no_tool_call" + result_notes = str(message.content or "") + steps.append( + AgentStep( + step_index=len(steps), + tool_name="", + tool_args={}, + observation_text=result_notes, + error=None, + elapsed_ms=turn_elapsed_ms, + tokens_used_delta=turn_tokens, + tokens_used_total=budget.tokens_used, + ) + ) + break + + finish_call = next( + (tc for tc in tool_calls if tc.function.name == FINISH_TOOL_NAME), None + ) + if finish_call is not None: + args = _safe_json_loads(finish_call.function.arguments) + result_refs = _normalize_finish_refs(args.get("refs")) + result_notes = str(args.get("notes") or "") + stop_reason = f"budget_{forced_reason}" if forced_reason else "finished" + steps.append( + AgentStep( + step_index=len(steps), + tool_name=FINISH_TOOL_NAME, + tool_args=args, + observation_text=f"refs={len(result_refs)} notes={result_notes!r}", + error=None, + elapsed_ms=turn_elapsed_ms, + tokens_used_delta=turn_tokens, + tokens_used_total=budget.tokens_used, + ) + ) + break + + if forced_reason is not None: + # Forced tool_choice=finish but the provider returned a + # different tool anyway (not observed in verification, but a + # budget cutoff must never loop past). Stop here regardless. + stop_reason = f"budget_{forced_reason}" + result_notes = str(message.content or "") or ( + "budget exhausted; provider did not return finish" + ) + steps.append( + AgentStep( + step_index=len(steps), + tool_name="", + tool_args={}, + observation_text=result_notes, + error="forced_finish_not_honored", + elapsed_ms=turn_elapsed_ms, + tokens_used_delta=turn_tokens, + tokens_used_total=budget.tokens_used, + ) + ) + break + + messages.append( + { + "role": "assistant", + "content": message.content or "", + "tool_calls": [ + { + "id": tc.id, + "type": "function", + "function": { + "name": tc.function.name, + "arguments": tc.function.arguments, + }, + } + for tc in tool_calls + ], + } + ) + first_tool_tokens_recorded = False + for tc in tool_calls: + tool_started = time.perf_counter() + args = _safe_json_loads(tc.function.arguments) + requested_name = str(tc.function.name or "") + canonical_name = tool_name_map.get(requested_name, requested_name) + try: + tool_result = await REGISTRY.dispatch(canonical_name, tool_ctx, args) + except Exception as exc: # noqa: BLE001 - one broken tool must not kill the episode + tool_result = ToolResult(text="", error=f"{type(exc).__name__}: {exc}") + tool_elapsed_ms = int((time.perf_counter() - tool_started) * 1000) + content = _tool_message_content(tool_result, max_chars=tool_ctx.budget.max_chars) + messages.append( + {"role": "tool", "tool_call_id": tc.id, "content": content} + ) + # Turn-level token usage is attributed to the first tool step in + # this turn (the completion that decided all calls in it); the + # rest are 0 to avoid double-counting the same LLM usage. + steps.append( + AgentStep( + step_index=len(steps), + tool_name=canonical_name, + tool_args=args, + observation_text=content, + error=tool_result.error, + elapsed_ms=tool_elapsed_ms if first_tool_tokens_recorded else turn_elapsed_ms + tool_elapsed_ms, + tokens_used_delta=0 if first_tool_tokens_recorded else turn_tokens, + tokens_used_total=budget.tokens_used, + ) + ) + first_tool_tokens_recorded = True + + return EpisodeResult( + refs=result_refs, + notes=result_notes, + steps=steps, + stop_reason=stop_reason, + tokens_used=budget.tokens_used, + model_name=model, + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/ref_resolution.py b/packages/shared-python/shared/services/retrieval/agent_explore/ref_resolution.py new file mode 100644 index 00000000..36e1e982 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/ref_resolution.py @@ -0,0 +1,94 @@ +"""Resolve ``finish.refs`` into the chunk_id-bearing shape ``resolve_workflow_references`` requires. + +Verified live: ``resolve_workflow_references`` -> ``hydrate_referenced_chunk_rows`` +drops any ref whose lookup key has an empty ``chunk_id`` (``row_utils. +build_reference_lookup_key`` + the ``ref_keys = [k for k in ref_keys if k[0] +and k[1]]`` guard in ``hydration/reference.py``) — a ``{document_id, +section_path}``-only ref silently resolves to zero ``referenced_chunks``, +which is exactly the shape ``agent_tools.CORPUS_SCHEMA.md``/``corpus.read`` +teaches the agent to cite (``corpus.read``'s rendered ``text`` — the only +thing the LLM ever sees — shows ``section_path``, never ``chunk_id``; +``chunk_id`` only appears in its structured ``payload``/``refs``, which the +LLM does not see). This module closes that gap at the harness boundary +instead of changing what the agent is taught to cite: for any ref missing +``chunk_id``, resolve that section's own body chunk — the same "one section, +one body chunk" lookup ``corpus.read``'s ``section_path`` branch already +performs (``agent_tools/tools/read.py``), not a new resolution rule. +""" + +from __future__ import annotations + +from typing import Any + +from sqlalchemy import select +from sqlalchemy.ext.asyncio import AsyncSession + +from shared.models.database.document import Document, DocumentChunk, DocumentSection +from shared.services.retrieval.search.lexical_text import normalize_section_path + +_BODY_CHUNK_TYPES = ("text", "page") + + +async def resolve_finish_refs( + db: AsyncSession, + *, + user_id: str, + namespace: str, + refs: list[dict[str, Any]], +) -> list[dict[str, Any]]: + """Return refs with ``chunk_id`` populated; drops refs that don't resolve.""" + document_ids = { + str(ref.get("document_id") or "").strip() for ref in refs if ref.get("document_id") + } + if not document_ids: + return [] + + documents = ( + ( + await db.execute( + select(Document) + .where(Document.document_id.in_(document_ids)) + .where(Document.user_id == user_id) + .where(Document.namespace == namespace) + .where(Document.status == "active") + ) + ) + .scalars() + .all() + ) + revision_by_doc = { + d.document_id: d.current_job_result_id for d in documents if d.current_job_result_id + } + + resolved: list[dict[str, Any]] = [] + for ref in refs: + document_id = str(ref.get("document_id") or "").strip() + chunk_id = str(ref.get("chunk_id") or "").strip() + if document_id and chunk_id: + resolved.append({"document_id": document_id, "chunk_id": chunk_id}) + continue + + section_path = str(ref.get("section_path") or "").strip() + job_result_id = revision_by_doc.get(document_id) + if not (document_id and section_path and job_result_id): + continue + + row = ( + await db.execute( + select(DocumentChunk.chunk_id) + .select_from(DocumentChunk) + .join( + DocumentSection, + DocumentSection.section_id == DocumentChunk.section_id, + ) + .where(DocumentChunk.document_id == document_id) + .where(DocumentChunk.job_result_id == job_result_id) + .where(DocumentSection.section_path == normalize_section_path(section_path)) + .where(DocumentChunk.chunk_type.in_(_BODY_CHUNK_TYPES)) + ) + ).first() + if row is None: + continue + resolved.append({"document_id": document_id, "chunk_id": str(row[0])}) + + return resolved diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/types.py b/packages/shared-python/shared/services/retrieval/agent_explore/types.py new file mode 100644 index 00000000..89bc90da --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/types.py @@ -0,0 +1,32 @@ +"""Result types shared between ``episode.py`` and ``bridge.py``.""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Any + + +@dataclass +class AgentStep: + """One tool call executed during the episode (one LLM turn may yield several).""" + + step_index: int + tool_name: str + tool_args: dict[str, Any] + observation_text: str + error: str | None + elapsed_ms: int + tokens_used_delta: int + tokens_used_total: int + + +@dataclass +class EpisodeResult: + """Everything ``bridge.py`` / the route need after the episode ends.""" + + refs: list[dict[str, Any]] + notes: str + steps: list[AgentStep] = field(default_factory=list) + stop_reason: str = "finished" + tokens_used: int = 0 + model_name: str = "" diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py b/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py index 2e228499..9f5b4284 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py @@ -21,8 +21,10 @@ ToolRegistry, ToolResult, ToolSpec, + capped_limit, register_tool, ) +from shared.services.retrieval.agent_tools.schema_doc import load_corpus_schema_text __all__ = [ "REGISTRY", @@ -31,5 +33,7 @@ "ToolRegistry", "ToolResult", "ToolSpec", + "capped_limit", + "load_corpus_schema_text", "register_tool", ] diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/registry.py b/packages/shared-python/shared/services/retrieval/agent_tools/registry.py index a4286f52..609de82e 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/registry.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/registry.py @@ -18,22 +18,40 @@ from sqlalchemy.ext.asyncio import AsyncSession +from shared.services.retrieval.settings import EVIDENCE_TEXT_CHAR_BUDGET + @dataclass(frozen=True) class ToolBudget: """Per-call output budget passed down to every tool via ``ToolContext``. - Tools that return an unbounded/ranked list (``recall``, ``grep``, asset - forward search) truncate to ``max_items`` and note the omission. Tools - that promise a complete, non-truncated set by contract (``node_filter``, - ``outline``) do not apply this budget to their matched-set cardinality — - see ``CORPUS_SCHEMA.md`` §6. + ``max_items`` is a hard ceiling on how many rows a tool that returns an + unbounded/ranked list (``recall``, ``grep``, asset forward search) may + return in one call: each such tool keeps its own smaller, tool-appropriate + default (e.g. ``grep``'s ``max_results``, ``recall``'s ``top_k``) but + clamps the caller-requested value to this ceiling via ``capped_limit()`` + below, and notes it in ``ToolResult.text`` when the request was clamped. + Tools that promise a complete, non-truncated set by contract + (``node_filter``, ``outline``) do not apply this budget to their + matched-set cardinality — see ``CORPUS_SCHEMA.md`` §6. + + ``max_chars`` caps the rendered ``ToolResult.text`` before it enters LLM + context. Applied in ``agent_explore.episode._tool_message_content`` (not + inside individual tools) so ``read`` can return full body text from the + tool while the harness still bounds what the model sees per turn. Aligned + with map-nav final evidence packing via ``EVIDENCE_TEXT_CHAR_BUDGET`` + (12_000). """ - max_chars: int = 8000 + max_chars: int = EVIDENCE_TEXT_CHAR_BUDGET max_items: int = 50 +def capped_limit(requested: int, budget: ToolBudget) -> int: + """Clamp a caller-requested row count to ``budget.max_items`` (min 1).""" + return max(1, min(requested, budget.max_items)) + + @dataclass class ToolContext: """Per-call execution context. One instance is built per tool dispatch.""" diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/schema_doc.py b/packages/shared-python/shared/services/retrieval/agent_tools/schema_doc.py new file mode 100644 index 00000000..37569589 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/schema_doc.py @@ -0,0 +1,21 @@ +"""Single loader for ``CORPUS_SCHEMA.md`` — the agent-facing corpus schema text. + +Both harnesses (Phase 3) read through this function instead of the file +directly, so there is exactly one place that resolves the path: the API +``/mcp`` server's ``instructions`` and ``agent_explore``'s system prompt must +stay byte-identical for the shared schema portion (see the module docstring +at the top of ``CORPUS_SCHEMA.md`` — "do not duplicate it elsewhere"). +""" + +from __future__ import annotations + +from functools import lru_cache +from pathlib import Path + +_SCHEMA_PATH = Path(__file__).with_name("CORPUS_SCHEMA.md") + + +@lru_cache(maxsize=1) +def load_corpus_schema_text() -> str: + """Return the verbatim contents of ``CORPUS_SCHEMA.md``.""" + return _SCHEMA_PATH.read_text(encoding="utf-8") diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/snippet.py b/packages/shared-python/shared/services/retrieval/agent_tools/snippet.py new file mode 100644 index 00000000..6dfed42c --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/snippet.py @@ -0,0 +1,72 @@ +"""Shared hit-anchored snippet builder for ``corpus.grep`` and ``corpus.recall``. + +Both tools locate a single pattern/term inside one chunk's text and need to +show a bounded excerpt around it. The shape is: head anchor + the window +around the (first) match + tail anchor, with ``...`` between spans that do +not touch. Overlapping/adjacent spans are merged before rendering so short +chunks never produce duplicate text or a stray ``...`` inside otherwise +continuous text. + +Only the first match is windowed. A single call passes a single +pattern/term, but that pattern can still occur more than once inside one +chunk (verified against real data); later occurrences in the same chunk are +not separately windowed here — use ``corpus.read`` on the chunk for the rest. +""" + +from __future__ import annotations + +HIT_CONTEXT_CHARS = 80 +HEAD_TAIL_CHARS = 50 + + +def _merge_spans(spans: list[tuple[int, int]]) -> list[tuple[int, int]]: + ordered = sorted(s for s in spans if s[1] > s[0]) + merged: list[list[int]] = [] + for start, end in ordered: + if merged and start <= merged[-1][1]: + merged[-1][1] = max(merged[-1][1], end) + else: + merged.append([start, end]) + return [(start, end) for start, end in merged] + + +def build_snippet( + text: str, + hit: tuple[int, int] | None = None, + *, + hit_context: int = HIT_CONTEXT_CHARS, + head_tail: int = HEAD_TAIL_CHARS, +) -> str: + """Head/tail anchor + first-match window, joined by ``...`` where spans don't touch. + + ``hit`` is the ``(start, end)`` char offset of the located match in + ``text``, or ``None`` when no specific position is known (falls back to + head/tail anchors only). Short text (<= ``head_tail * 2`` chars) is + returned unchanged. + """ + if not text: + return "" + if len(text) <= head_tail * 2: + return text + + spans: list[tuple[int, int]] = [ + (0, head_tail), + (max(len(text) - head_tail, 0), len(text)), + ] + if hit is not None: + hit_start, hit_end = hit + spans.append( + (max(hit_start - hit_context, 0), min(hit_end + hit_context, len(text))) + ) + + merged = _merge_spans(spans) + parts: list[str] = [] + prev_end = 0 + for start, end in merged: + if start > prev_end: + parts.append("...") + parts.append(text[start:end]) + prev_end = end + if prev_end < len(text): + parts.append("...") + return "".join(parts) diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/grep.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/grep.py index 81bca87e..af7224c7 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/tools/grep.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/grep.py @@ -4,6 +4,11 @@ revision. Reports a total match count (over the full in-scope corpus, not just the returned page) alongside capped snippets, so ANY/ALL logic can close over body text the same way ``corpus.node_filter`` closes over titles/summaries. + +Snippets are built by the shared ``agent_tools.snippet.build_snippet`` (head ++ first-match window + tail, ``...``-joined, overlap-merged) — the same +mechanism ``corpus.recall``'s term channel uses, so the two tools don't carry +duplicate window-slicing logic or drift to different constants. """ from __future__ import annotations @@ -17,11 +22,16 @@ from shared.services.retrieval.agent_tools.registry import ( ToolContext, ToolResult, + capped_limit, register_tool, ) +from shared.services.retrieval.agent_tools.snippet import ( + HIT_CONTEXT_CHARS, + build_snippet, +) _DEFAULT_MAX_RESULTS = 30 -_DEFAULT_CONTEXT_CHARS = 80 +_DEFAULT_CONTEXT_CHARS = HIT_CONTEXT_CHARS def _build_scope_filters( @@ -70,7 +80,8 @@ async def grep(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: return ToolResult(text="", error="grep requires pattern") is_regex = bool(args.get("is_regex", False)) context_chars = int(args.get("context_chars") or _DEFAULT_CONTEXT_CHARS) - max_results = int(args.get("max_results") or _DEFAULT_MAX_RESULTS) + requested_max_results = int(args.get("max_results") or _DEFAULT_MAX_RESULTS) + max_results = capped_limit(requested_max_results, ctx.budget) document_ids = [ str(d).strip() for d in (args.get("document_ids") or []) if str(d).strip() ] @@ -128,12 +139,9 @@ async def grep(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: for chunk_id, document_id, chunk_type, content, section_path, source_file_name in rows: text = str(content or "") match = compiled.search(text) - if match is None: - snippet = text[: context_chars * 2] - else: - start = max(match.start() - context_chars, 0) - end = min(match.end() + context_chars, len(text)) - snippet = text[start:end] + snippet = build_snippet( + text, match.span() if match else None, hit_context=context_chars + ) results.append( { "document_id": document_id, @@ -146,6 +154,8 @@ async def grep(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: ) lines = [f"total_matches={total_matches} returned={len(results)}"] + if requested_max_results > max_results: + lines.append(f"note: capped to budget.max_items={ctx.budget.max_items}") for r in results: lines.append(f"- {r['source_file_name']} / {r['section_path']}: {r['snippet']!r}") diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py index 84116afb..d715a063 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py @@ -147,7 +147,8 @@ async def node_filter(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: if chunk_types: chunk_rows = await ctx.db.execute( select(DocumentChunk.section_id, DocumentChunk.chunk_type).where( - DocumentChunk.document_id.in_([d for d, _ in revision_pairs]) + DocumentChunk.document_id.in_([d for d, _ in revision_pairs]), + DocumentChunk.job_result_id.in_([r for _, r in revision_pairs]), ) ) allowed_section_ids = { diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py index 2b532a3f..dd1f09e3 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py @@ -35,9 +35,6 @@ ToolResult, register_tool, ) -from shared.services.retrieval.hydration.asset_inline import ( - inline_assets_at_placeholders, -) from shared.services.retrieval.hydration.assets import ( enrich_rows_with_retrieval_asset_url, ) @@ -45,7 +42,6 @@ from shared.services.retrieval.hydration.result_assembly import ( _compose_table_content, _compose_text_content, - _connected_display_by_target, _image_display_content, ) from shared.services.retrieval.hydration.row_utils import normalize_chunk_type @@ -57,23 +53,12 @@ _SAME_AS_MARKER_RE = re.compile(r"\[SAME-AS (.+?) p(\d+)\]") _BODY_CHUNK_TYPES = ("text", "page") - -def _compose_page_content( - row: dict[str, Any], rows_by_chunk_id: dict[str, dict[str, Any]] -) -> str: - """Like ``_compose_text_content`` but never downgraded to a summary.""" - base_content = str(row.get("content") or "") - display_by_target = _connected_display_by_target(row, rows_by_chunk_id) - if not display_by_target: - return base_content - metadata = row.get("chunk_metadata") or {} - connections = metadata.get("connect_to") if isinstance(metadata, dict) else None - content, _embedded = inline_assets_at_placeholders( - base_content, - connections=connections if isinstance(connections, list) else [], - display_by_target=display_by_target, - ) - return content +# ``_compose_text_content`` doesn't branch on chunk_type — it just inlines +# connect_to placeholders — so the ``page`` branch below reuses it directly +# instead of carrying a near-identical copy. The behavioral difference from +# retrieval's own page handling (never downgrading to a summary — see the +# module docstring) comes entirely from *not* calling ``_page_summary`` +# first, which this module never did. async def _resolve_same_as_markers( @@ -369,7 +354,7 @@ async def read(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: if chunk_type == "text": composed["content"] = _compose_text_content(row, rows_by_chunk_id) if include_assets else row.get("content") elif chunk_type == "page": - composed["content"] = _compose_page_content(row, rows_by_chunk_id) if include_assets else row.get("content") + composed["content"] = _compose_text_content(row, rows_by_chunk_id) if include_assets else row.get("content") elif chunk_type == "table": composed["content"] = _compose_table_content(row, rows_by_chunk_id) elif chunk_type == "image": diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py index 62b870a2..a4c7f61d 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py @@ -20,6 +20,11 @@ there is no persisted precedent for a different weight ratio between them (the old 3-channel weights of path=1.0/content=2.0/term=1.5 no longer exist in code — only path=1.0/content=2.0 survive in ``nav.knowhere_hybrid``). + +The term channel's snippet and the rendered ``text`` preview both go through +the shared ``agent_tools.snippet.build_snippet`` (head + first-match window + +tail, ``...``-joined, overlap-merged) — the same mechanism ``corpus.grep`` +uses, so window-slicing constants live in one place. """ from __future__ import annotations @@ -33,14 +38,16 @@ from shared.services.retrieval.agent_tools.registry import ( ToolContext, ToolResult, + capped_limit, register_tool, ) +from shared.services.retrieval.agent_tools.snippet import build_snippet from shared.services.retrieval.search.map_unit_discovery import map_unit_discovery from shared.services.retrieval.search.scoring import merge_channels_rrf _SUPPORTED_CHANNELS = {"path_content", "term"} _RESERVED_CHANNELS = {"vector"} -_DEFAULT_TOP_K = 20 +_DEFAULT_TOP_K = 10 _TERM_CHANNEL_SQL = """ SELECT dmu.document_id, dmu.job_result_id, dmu.section_id, ds.section_path, @@ -127,9 +134,9 @@ async def _term_channel_rows( continue if chunk_types and chunk.chunk_type not in chunk_types: continue - needle_pos = unit_row["term_search_text_lower"].find(needle) - window_start = max(needle_pos - 80, 0) - window_end = min(needle_pos + len(needle) + 80, len(unit_row["term_search_text_lower"])) + haystack = unit_row["term_search_text_lower"] + needle_pos = haystack.find(needle) + hit = (needle_pos, needle_pos + len(needle)) if needle_pos >= 0 else None results.append( { "chunk_id": chunk.chunk_id, @@ -138,7 +145,7 @@ async def _term_channel_rows( "section_path": unit_row["section_path"], "source_file_name": unit_row["source_file_name"], "chunk_type": chunk.chunk_type, - "snippet": unit_row["term_search_text_lower"][window_start:window_end], + "snippet": build_snippet(haystack, hit), } ) return results @@ -176,7 +183,8 @@ async def recall(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: query = str(args.get("query") or "").strip() if not query: return ToolResult(text="", error="recall requires query") - top_k = int(args.get("top_k") or _DEFAULT_TOP_K) + requested_top_k = int(args.get("top_k") or _DEFAULT_TOP_K) + top_k = capped_limit(requested_top_k, ctx.budget) document_ids = [ str(d).strip() for d in (args.get("document_ids") or []) if str(d).strip() ] @@ -233,8 +241,10 @@ async def recall(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: lines = [f"candidates={len(fused)}"] if reserved_requested: lines.append(f"note: channels {sorted(reserved_requested)} are reserved, not run") + if requested_top_k > top_k: + lines.append(f"note: capped to budget.max_items={ctx.budget.max_items}") for row in fused: - snippet = str(row.get("content") or row.get("snippet") or "")[:200] + snippet = build_snippet(str(row.get("content") or row.get("snippet") or "")) lines.append( f"- {row.get('source_file_name')} / {row.get('section_path')} " f"score={row.get('score')}: {snippet!r}" diff --git a/packages/shared-python/shared/services/retrieval/execution/routes.py b/packages/shared-python/shared/services/retrieval/execution/routes.py index 3f6a8270..23b17859 100644 --- a/packages/shared-python/shared/services/retrieval/execution/routes.py +++ b/packages/shared-python/shared/services/retrieval/execution/routes.py @@ -1,6 +1,7 @@ from __future__ import annotations import asyncio +import os import resource import time from contextlib import AbstractAsyncContextManager @@ -60,6 +61,20 @@ def _render_rows_evidence(rows: list[dict]) -> str: return render_evidence_blocks(list(groups.items())) +_AGENTIC_ROUTERS = {"mapnav", "agent_explore"} +_AGENTIC_ROUTER_ENV = "RETRIEVAL_AGENTIC_ROUTER" + + +def _resolve_agentic_router() -> str: + """``RETRIEVAL_AGENTIC_ROUTER`` env switch: ``mapnav`` (default, current + production route) or ``agent_explore`` (Phase 3 of + ``.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md``, + pending its Phase 4 evaluation gate before it can become the default). + """ + value = os.environ.get(_AGENTIC_ROUTER_ENV, "").strip().lower() + return value if value in _AGENTIC_ROUTERS else "mapnav" + + async def run_retrieval_route( context: RetrievalRouteContext, ) -> RetrievalRouteOutcome: @@ -67,10 +82,13 @@ async def run_retrieval_route( if small_corpus_outcome is not None: return small_corpus_outcome - # Explicit False → classic 3-channel top-K. None/True → map-nav (default). + # Explicit False → classic map-unit BM25 top-K. None/True → agentic, + # routed by RETRIEVAL_AGENTIC_ROUTER (default mapnav). if context.use_agentic is False: return await _run_classic_topk_route(context) + if _resolve_agentic_router() == "agent_explore": + return await _run_agent_explore_route(context) return await _run_mapnav_route(context) @@ -190,6 +208,118 @@ async def _run_classic_topk_route( ) +async def _run_agent_explore_route( + context: RetrievalRouteContext, +) -> RetrievalRouteOutcome: + """Phase 3 agentic path: in-process ``corpus.*`` tool-calling loop. + + Selected when ``RETRIEVAL_AGENTIC_ROUTER=agent_explore``; ``mapnav`` + remains the default route until this one passes its Phase 4 evaluation + gate. See ``shared/services/retrieval/agent_explore/``. + """ + from shared.services.retrieval.agent_explore.bridge import build_decision_trace + from shared.services.retrieval.agent_explore.episode import ( + run_agent_explore_episode, + ) + from shared.services.retrieval.agent_explore.ref_resolution import ( + resolve_finish_refs, + ) + from shared.services.retrieval.trace import TraceRecorder + + episode_started = time.perf_counter() + episode = await run_agent_explore_episode( + db=context.db, + user_id=context.user_id, + namespace=context.namespace, + query=context.query, + ) + logger.info( + "retrieval agent_explore stage=episode seconds={:.3f} refs={} " + "steps={} tokens={} stop_reason={}".format( + time.perf_counter() - episode_started, + len(episode.refs), + len(episode.steps), + episode.tokens_used, + episode.stop_reason, + ) + ) + + # episode.refs are document_id + section_path (what the agent actually + # sees in tool text); resolve_workflow_references requires chunk_id — + # see ref_resolution.py's module docstring for why this bridge exists. + chunk_refs = await resolve_finish_refs( + context.db, + user_id=context.user_id, + namespace=context.namespace, + refs=episode.refs, + ) + resolved = await resolve_workflow_references( + db=context.db, + user_id=context.user_id, + namespace=context.namespace, + refs=chunk_refs, + revision_pins=context.revision_pins, + ) + assembled_rows = await assemble_retrieval_results( + db=context.db, + rows=resolved.rows, + exclude_document_ids=context.exclude_document_ids, + exclude_sections=context.exclude_sections, + allowed_chunk_types=context.allowed_chunk_types, + revision_pins=context.revision_pins, + ) + + decision_steps = build_decision_trace(episode.steps) + decision_trace = [step.to_dict() for step in decision_steps] + selected_doc_ids = list( + {row.get("document_id", "") for row in resolved.rows if row.get("document_id")} + ) + + trace = TraceRecorder( + context.db, + user_id=context.user_id, + namespace=context.namespace, + query=context.query, + top_k=context.top_k, + chunk_types=context.allowed_chunk_types, + policy_name="agent_explore_v1", + ) + await trace.create_run() + for step in decision_steps: + trace.record_decision_trace_step(step) + if episode.stop_reason.startswith("budget_"): + trace.record_budget_stop(episode.stop_reason.removeprefix("budget_")) + await trace.complete( + assembled_rows, + "agent_explore", + token_count=episode.tokens_used, + model_name=episode.model_name, + selected_doc_ids=selected_doc_ids, + ) + + evidence_text = _render_rows_evidence(assembled_rows) + response = { + "namespace": context.namespace, + "query": context.query, + "router_used": "agent_explore", + "evidence_text": evidence_text, + "answer_text": "", + "referenced_chunks": resolved.refs, + "results": assembled_rows, + "stop_reason": episode.stop_reason, + "decision_trace": decision_trace, + } + return RetrievalRouteOutcome( + response=response, + hit_stats_results=resolved.refs, + completion_label="AGENT EXPLORE RETRIEVAL", + completion_count=len(resolved.refs), + completion_detail=( + f"chunks | evidence={len(evidence_text)} chars | router=agent_explore" + ), + ) + + async def _run_mapnav_route( context: RetrievalRouteContext, ) -> RetrievalRouteOutcome: diff --git a/packages/shared-python/shared/services/retrieval/nav_config.py b/packages/shared-python/shared/services/retrieval/nav_config.py index 48067194..c7338f09 100644 --- a/packages/shared-python/shared/services/retrieval/nav_config.py +++ b/packages/shared-python/shared/services/retrieval/nav_config.py @@ -16,10 +16,11 @@ from typing import Any from shared.services.retrieval.nav.nav_types import NavConfig +from shared.services.retrieval.settings import EVIDENCE_TEXT_CHAR_BUDGET # Migrated probe / llm_api.env stack. MAPNAV_MODEL = "deepseek-v4-flash" -MAPNAV_EVIDENCE_CHARS = 12_000 +MAPNAV_EVIDENCE_CHARS = EVIDENCE_TEXT_CHAR_BUDGET MAPNAV_TOKEN_LIMIT = 100_000 MAPNAV_PLANNER_THINK_MAX_TOKENS = 16_384 MAPNAV_TRACE_RAW_CHARS = 2_000 diff --git a/packages/shared-python/shared/services/retrieval/settings.py b/packages/shared-python/shared/services/retrieval/settings.py index f2e24b56..7e7df316 100644 --- a/packages/shared-python/shared/services/retrieval/settings.py +++ b/packages/shared-python/shared/services/retrieval/settings.py @@ -6,6 +6,11 @@ RRF_K = 60 DEFAULT_TOP_K = 10 +# Final evidence / tool-observation text budget (characters). Shared by map-nav +# evidence packing (``nav_config.MAPNAV_EVIDENCE_CHARS``) and agent tool-loop +# harness caps (``ToolBudget.max_chars`` in ``agent_explore/episode.py``). +EVIDENCE_TEXT_CHAR_BUDGET = 12_000 + VALID_CHUNK_TYPES: set[str] = {"text", "image", "table", "page"} ASSET_CHUNK_TYPES: set[str] = {"image", "table"} From 1e80906f1206a2f7002dc8cde410cde8b97eb82f Mon Sep 17 00:00:00 2001 From: chengke <404835780@qq.com> Date: Tue, 8 Sep 2026 17:29:08 +0800 Subject: [PATCH 08/15] feat(retrieval): improve agent exploration and message handling Enhanced the agent exploration logic by implementing a two-phase fix for stale tool-message collapsing, ensuring efficient message management across turns. Introduced a fallback mechanism for trajectory references, allowing the system to utilize previously read content when no current references are available. Updated documentation to clarify the requirements for `refs` when calling `{FINISH_TOOL_NAME}` and refined the handling of tool messages to prevent unnecessary resends, optimizing performance and clarity in the exploration process. --- .../scripts/debug_agent_explore_episode.py | 90 +++++ apps/worker/scripts/debug_finish_raw_args.py | 65 ++++ .../changheba_archive_eval_queries.json | 93 +++++ .../worker/scripts/run_agentic_router_eval.py | 321 ++++++++++++++++++ .../retrieval/agent_explore/config.py | 7 + .../retrieval/agent_explore/episode.py | 130 ++++++- 6 files changed, 703 insertions(+), 3 deletions(-) create mode 100644 apps/worker/scripts/debug_agent_explore_episode.py create mode 100644 apps/worker/scripts/debug_finish_raw_args.py create mode 100644 apps/worker/scripts/fixtures/changheba_archive_eval_queries.json create mode 100644 apps/worker/scripts/run_agentic_router_eval.py diff --git a/apps/worker/scripts/debug_agent_explore_episode.py b/apps/worker/scripts/debug_agent_explore_episode.py new file mode 100644 index 00000000..a74e9928 --- /dev/null +++ b/apps/worker/scripts/debug_agent_explore_episode.py @@ -0,0 +1,90 @@ +"""Audit-only: dump every step of one ``agent_explore`` episode. + +Prints, for each LLM turn / tool call: tool name, args, elapsed ms, +tokens_used_delta (turn-level, attributed to the first tool step — see +``episode.py``), tokens_used_total (cumulative), observation length (chars +sent back into the LLM's context), and error. Also prints the final +``EpisodeResult`` (refs/notes/stop_reason). + +Read-only diagnostic; does not modify any behavior. + +Usage: + cd apps/worker + uv run python scripts/debug_agent_explore_episode.py --query-id q04 + uv run python scripts/debug_agent_explore_episode.py --query "..." --token-limit 200000 +""" + +from __future__ import annotations + +import argparse +import asyncio +import json +import os +import sys +from pathlib import Path + +from dotenv import load_dotenv + +_SCRIPT_DIR = Path(__file__).resolve().parent +_REPO_ROOT = _SCRIPT_DIR.parents[1] +sys.path.insert(0, str(_REPO_ROOT / "packages" / "shared-python")) +sys.path.insert(0, str(_SCRIPT_DIR.parent)) + +load_dotenv(_SCRIPT_DIR.parent / ".env") +os.environ.setdefault("LOCAL_DEBUG", "0") +os.environ.setdefault("LLM_MOCK_ENABLED", "false") + +FIXTURE_PATH = _SCRIPT_DIR / "fixtures" / "changheba_archive_eval_queries.json" + + +async def main() -> None: + parser = argparse.ArgumentParser() + parser.add_argument("--query-id", default=None) + parser.add_argument("--query", default=None) + parser.add_argument("--user-id", default="debug_local_user") + parser.add_argument("--namespace", default="default") + parser.add_argument("--token-limit", type=int, default=None) + args = parser.parse_args() + + query = args.query + if args.query_id: + fixture = json.loads(FIXTURE_PATH.read_text(encoding="utf-8")) + match = next(q for q in fixture["queries"] if q["id"] == args.query_id) + query = match["query"] + if not query: + raise SystemExit("need --query or --query-id") + + from shared.core.database import get_db_context + from shared.services.retrieval.agent_explore.budget import EpisodeBudget + from shared.services.retrieval.agent_explore.episode import run_agent_explore_episode + + budget = EpisodeBudget(token_limit=args.token_limit) if args.token_limit else None + + print(f"query: {query!r}") + async with get_db_context() as db: + episode = await run_agent_explore_episode( + db=db, + user_id=args.user_id, + namespace=args.namespace, + query=query, + budget=budget, + ) + + print(f"\nstop_reason={episode.stop_reason} tokens_used={episode.tokens_used} " + f"model={episode.model_name}") + print(f"final refs ({len(episode.refs)}): {json.dumps(episode.refs, ensure_ascii=False)}") + print(f"final notes: {episode.notes!r}") + print(f"\n{'#':>3} {'tool':<28} {'ms':>6} {'delta':>7} {'total':>7} {'obs_chars':>9} err") + for step in episode.steps: + args_preview = json.dumps(step.tool_args, ensure_ascii=False)[:80] + err = step.error or "" + print( + f"{step.step_index:>3} {step.tool_name or '(none)':<28} " + f"{step.elapsed_ms:>6} {step.tokens_used_delta:>7} " + f"{step.tokens_used_total:>7} {len(step.observation_text):>9} {err}" + ) + print(f" args: {args_preview}") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/apps/worker/scripts/debug_finish_raw_args.py b/apps/worker/scripts/debug_finish_raw_args.py new file mode 100644 index 00000000..9a6099fe --- /dev/null +++ b/apps/worker/scripts/debug_finish_raw_args.py @@ -0,0 +1,65 @@ +"""Audit-only: monkeypatch to see the RAW ``finish`` tool_call.function.arguments +string the LLM actually sent, before ``_safe_json_loads`` parses it. Does not +modify any file — patches the imported module object in this process only. +""" + +from __future__ import annotations + +import asyncio +import json +import os +import sys +from pathlib import Path + +from dotenv import load_dotenv + +_SCRIPT_DIR = Path(__file__).resolve().parent +_REPO_ROOT = _SCRIPT_DIR.parents[1] +sys.path.insert(0, str(_REPO_ROOT / "packages" / "shared-python")) +sys.path.insert(0, str(_SCRIPT_DIR.parent)) + +load_dotenv(_SCRIPT_DIR.parent / ".env") +os.environ.setdefault("LOCAL_DEBUG", "0") +os.environ.setdefault("LLM_MOCK_ENABLED", "false") + +FIXTURE_PATH = _SCRIPT_DIR / "fixtures" / "changheba_archive_eval_queries.json" + + +async def main() -> None: + import argparse + + parser = argparse.ArgumentParser() + parser.add_argument("--query-id", required=True) + args = parser.parse_args() + + fixture = json.loads(FIXTURE_PATH.read_text(encoding="utf-8")) + match = next(q for q in fixture["queries"] if q["id"] == args.query_id) + query = match["query"] + + from shared.services.retrieval.agent_explore import episode as episode_mod + + original_safe_json_loads = episode_mod._safe_json_loads + + def _spy(raw): + print(f"[SPY] raw arguments received: {raw!r}") + return original_safe_json_loads(raw) + + episode_mod._safe_json_loads = _spy + + from shared.core.database import get_db_context + + print(f"query: {query!r}") + async with get_db_context() as db: + result = await episode_mod.run_agent_explore_episode( + db=db, + user_id="debug_local_user", + namespace="default", + query=query, + ) + print(f"\nfinal refs: {result.refs}") + print(f"final notes: {result.notes!r}") + print(f"stop_reason: {result.stop_reason}") + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/apps/worker/scripts/fixtures/changheba_archive_eval_queries.json b/apps/worker/scripts/fixtures/changheba_archive_eval_queries.json new file mode 100644 index 00000000..b1c640b8 --- /dev/null +++ b/apps/worker/scripts/fixtures/changheba_archive_eval_queries.json @@ -0,0 +1,93 @@ +{ + "version": "1.0", + "source_docx": "/Users/wuchengke/Desktop/temp/test_docs/yideng/zh_档案知识库测试样例.docx", + "corpus": { + "user_id": "debug_local_user", + "namespace": "default", + "documents": [ + "zh_四川省大渡河长河坝水电站可行性研究报告1.pdf", + "zh_四川省大渡河长河坝水电站可行性研究报告2.pdf" + ] + }, + "queries": [ + { + "id": "q01", + "label": "roles_wangrenkun", + "query": "王仁坤作为不同角色参与了哪些设计成果的编制?", + "answer_notes": [ + "作为总工程师:报告1综合说明封面、报告2水文泥沙封面", + "作为审查人:报告1审查意见汇编(报告2水文泥沙正文未检出审查人署名)" + ], + "expected_keywords": ["王仁坤", "总工程师", "审查"] + }, + { + "id": "q02", + "label": "hydro_stations", + "query": "长河坝水电站上下游分别设置了几个水文站?水文站的水位观测、流量测验情况分别是怎样的?", + "answer_notes": [ + "报告2水文泥沙2.3:干流3站(上大金/丹巴、下泸定),支流金汤、康定", + "水位枯2/汛4(涨水加测),流量流速仪与浮标结合" + ], + "expected_keywords": ["水文", "丹巴", "泸定", "水位", "流量"] + }, + { + "id": "q03", + "label": "project_status_power_scope", + "query": "长河坝水电站的工程地位和作用是什么?供电范围是什么?", + "answer_notes": [ + "报告1综合说明1.4:装机约2600MW,大渡河重点开发工程,川电东送/西电东送", + "供电范围:四川主网,华中、华东电网" + ], + "expected_keywords": ["2600", "川电东送", "华东", "华中"] + }, + { + "id": "q04", + "label": "survey_design_challenges", + "query": "长河坝水电站勘察设计过程中遇到的难点有哪些?采取了哪些关键技术解决难点?", + "answer_notes": [ + "难点:高地震烈度、深厚覆盖层、世界级砾石土心墙堆石坝", + "关键技术:砾石土直心墙、混凝土防渗墙、覆盖层处理、抗震措施" + ], + "expected_keywords": ["砾石土", "防渗墙", "地震", "覆盖层"] + }, + { + "id": "q05", + "label": "installed_capacity", + "query": "长河坝水电站在可行性研究阶段推荐的水电站装机容量是多少?安装几台机组?单机容量是多少?", + "answer_notes": [ + "报告1综合说明1.4.11/1.4.13:推荐260万kW,4台,单机65万kW混流式" + ], + "expected_keywords": ["260", "4", "65", "万 kW"] + }, + { + "id": "q06", + "label": "reservoir_operation", + "query": "水库和电站运行方式是怎样的?", + "answer_notes": [ + "报告1综合说明1.4.14:日/周调节,1690m-1680m,特枯可降至1650m", + "黄金坪投产后自由调峰;投产前须保证5%生态流量" + ], + "expected_keywords": ["1690", "1680", "调峰", "1650"] + }, + { + "id": "q07", + "label": "project_class_standards", + "query": "长河坝水电站的工程等别和设计标准是怎样的?", + "answer_notes": [ + "报告1综合说明1.6.1:一等大(1)型,1级建筑物", + "洪水:挡泄1000年一遇7650,厂房200年6670;地震:壅水Ⅸ度359gal,非壅水Ⅷ度222gal" + ], + "expected_keywords": ["一等大", "1000", "7650", "Ⅸ"] + }, + { + "id": "q08", + "label": "dam_type_selection", + "query": "长河坝水电站有几种坝型选择?最终选择的是哪种?依据是什么?", + "answer_notes": [ + "报告1综合说明1.6.2:比选3种(直心墙、斜心墙、沥青混凝土心墙)", + "最终选择砾石土直心墙堆石坝;沥青心墙接头复杂、经验少" + ], + "expected_keywords": ["砾石土直心墙", "沥青", "三种", "斜心墙"] + } + ] +} diff --git a/apps/worker/scripts/run_agentic_router_eval.py b/apps/worker/scripts/run_agentic_router_eval.py new file mode 100644 index 00000000..4f4932dc --- /dev/null +++ b/apps/worker/scripts/run_agentic_router_eval.py @@ -0,0 +1,321 @@ +"""Phase 4 router comparison: mapnav vs agent_explore on a fixed query set. + +Reads ``fixtures/changheba_archive_eval_queries.json`` (sourced from +``zh_档案知识库测试样例.docx``) and runs each query through +``run_retrieval_route`` directly — bypassing the Redis result cache, which +does not key on ``RETRIEVAL_AGENTIC_ROUTER`` and would otherwise return the +first router's answer for both runs of the same query. + +Usage: + cd apps/worker + uv run python scripts/run_agentic_router_eval.py + uv run python scripts/run_agentic_router_eval.py --query-id q05 + uv run python scripts/run_agentic_router_eval.py --router agent_explore +""" + +from __future__ import annotations + +import argparse +import asyncio +import json +import os +import sys +import time +from contextlib import contextmanager +from dataclasses import dataclass +from datetime import datetime +from pathlib import Path +from typing import Any + +from dotenv import load_dotenv + +_SCRIPT_DIR = Path(__file__).resolve().parent +_REPO_ROOT = _SCRIPT_DIR.parents[1] +_SHARED_PYTHON = _REPO_ROOT / "packages" / "shared-python" +sys.path.insert(0, str(_SHARED_PYTHON)) +sys.path.insert(0, str(_SCRIPT_DIR.parent)) + +load_dotenv(_SCRIPT_DIR.parent / ".env") +os.environ.setdefault("LOCAL_DEBUG", "0") +os.environ.setdefault("LLM_MOCK_ENABLED", "false") + +FIXTURE_PATH = _SCRIPT_DIR / "fixtures" / "changheba_archive_eval_queries.json" +ROUTERS = ("mapnav", "agent_explore") +TOP_K = 10 + + +@contextmanager +def temporary_env(overrides: dict[str, str]): + previous = {key: os.environ.get(key) for key in overrides} + os.environ.update(overrides) + try: + yield + finally: + for key, old in previous.items(): + if old is None: + os.environ.pop(key, None) + else: + os.environ[key] = old + + +def _count_llm_steps(decision_trace: list[dict[str, Any]], router: str) -> int: + if router == "mapnav": + return sum( + 1 + for step in decision_trace + if step.get("phase") in ("plan", "harvest", "plan_control") + ) + return sum( + 1 + for step in decision_trace + if step.get("phase") in ("tool_call", "finish") + or (step.get("decision") or {}).get("action") not in ("", "no_tool_call", None) + ) + + +def _keyword_hits(evidence_text: str, keywords: list[str]) -> tuple[int, list[str]]: + text = evidence_text or "" + hits = [kw for kw in keywords if kw and kw in text] + return len(hits), hits + + +@dataclass +class RunMetrics: + query_id: str + router: str + total_ms: int + router_used: str + stop_reason: str + refs: int + results: int + evidence_chars: int + llm_steps: int + keyword_hits: int + keyword_total: int + matched_keywords: list[str] + error: str | None = None + + +async def _run_one( + *, + user_id: str, + namespace: str, + query: str, + query_id: str, + router: str, + expected_keywords: list[str], +) -> RunMetrics: + from dataclasses import replace + + from shared.core.database import get_db_context + from shared.services.retrieval.execution.plan import project_public_retrieval_response + from shared.services.retrieval.execution.query_request import RetrievalQuery + from shared.services.retrieval.execution.revision_pins import ( + capture_revision_pins, + is_revision_generation_stable, + ) + from shared.services.retrieval.execution.routes import run_retrieval_route + from shared.services.retrieval.settings import INTERNAL_RECALL_K_MULTIPLIER + + started = time.monotonic() + error: str | None = None + response: dict[str, Any] = {} + try: + with temporary_env({"RETRIEVAL_AGENTIC_ROUTER": router}): + async with get_db_context() as db: + request = RetrievalQuery.from_parameters( + db=db, + user_id=user_id, + namespace=namespace, + query=query, + top_k=TOP_K, + exclude_document_ids=[], + exclude_sections=[], + use_agentic=True, + ) + revision_pins = await capture_revision_pins( + db, user_id=user_id, namespace=namespace + ) + if not await is_revision_generation_stable( + db, + user_id=user_id, + namespace=namespace, + pins=revision_pins, + ): + revision_pins = await capture_revision_pins( + db, user_id=user_id, namespace=namespace + ) + effective_recall_k = ( + request.internal_recall_k + if request.internal_recall_k is not None + else TOP_K * INTERNAL_RECALL_K_MULTIPLIER + ) + context = replace( + request.build_route_context(), + revision_pins=revision_pins, + effective_recall_k=effective_recall_k, + ) + outcome = await run_retrieval_route(context) + response = await project_public_retrieval_response(outcome.response) + except Exception as exc: # noqa: BLE001 - eval runner must continue + error = f"{type(exc).__name__}: {exc}" + + elapsed_ms = int((time.monotonic() - started) * 1000) + evidence = str(response.get("evidence_text") or "") + decision_trace = response.get("decision_trace") or [] + hits, matched = _keyword_hits(evidence, expected_keywords) + return RunMetrics( + query_id=query_id, + router=router, + total_ms=elapsed_ms, + router_used=str(response.get("router_used") or router), + stop_reason=str(response.get("stop_reason") or ""), + refs=len(response.get("referenced_chunks") or []), + results=len(response.get("results") or []), + evidence_chars=len(evidence), + llm_steps=_count_llm_steps(decision_trace, router), + keyword_hits=hits, + keyword_total=len(expected_keywords), + matched_keywords=matched, + error=error, + ) + + +def _render_markdown( + fixture: dict[str, Any], + runs: list[RunMetrics], + output_dir: Path, +) -> str: + by_key = {(r.query_id, r.router): r for r in runs} + lines = [ + "# Agentic Router Eval (Phase 4)\n", + f"Fixture: `{FIXTURE_PATH.name}`\n", + f"Corpus: `{fixture['corpus']['namespace']}` / " + f"{len(fixture['corpus']['documents'])} documents\n", + f"Generated: {datetime.now().isoformat(timespec='seconds')}\n", + f"Output dir: `{output_dir}`\n", + "\n## Summary\n", + "| Q | Query (short) | Router | ms | LLM steps | refs | kw hit | stop |\n", + "|---|---|---|---:|---:|---:|---:|---|\n", + ] + for item in fixture["queries"]: + qid = item["id"] + short = item["query"][:28] + ("…" if len(item["query"]) > 28 else "") + for router in ROUTERS: + r = by_key.get((qid, router)) + if r is None: + continue + kw = f"{r.keyword_hits}/{r.keyword_total}" + stop = (r.stop_reason or r.error or "")[:24] + lines.append( + f"| {qid} | {short} | {router} | {r.total_ms} | " + f"{r.llm_steps} | {r.refs} | {kw} | {stop} |\n" + ) + + mapnav_ms = [r.total_ms for r in runs if r.router == "mapnav" and not r.error] + agent_ms = [r.total_ms for r in runs if r.router == "agent_explore" and not r.error] + + def _p50(values: list[int]) -> int | None: + if not values: + return None + ordered = sorted(values) + return ordered[len(ordered) // 2] + + lines.extend( + [ + "\n## Aggregate latency (successful runs only)\n", + f"- mapnav p50: {_p50(mapnav_ms)} ms ({len(mapnav_ms)} runs)\n", + f"- agent_explore p50: {_p50(agent_ms)} ms ({len(agent_ms)} runs)\n", + "\n## Notes\n", + "- Runs bypass Redis retrieval cache (direct ``run_retrieval_route``).\n", + "- ``kw hit`` = expected keywords found in ``evidence_text`` " + "(proxy for recall quality, not a full answer judge).\n", + "- Phase 0 ad-hoc queries are separate; this set is the 8 questions " + "from ``zh_档案知识库测试样例.docx``.\n", + ] + ) + return "".join(lines) + + +async def main() -> None: + parser = argparse.ArgumentParser(description="Compare mapnav vs agent_explore") + parser.add_argument( + "--fixture", + default=str(FIXTURE_PATH), + help="Path to eval queries JSON", + ) + parser.add_argument( + "--output-dir", + "-o", + default=None, + help="Output directory (default: /tmp/agentic_router_eval/)", + ) + parser.add_argument( + "--query-id", + action="append", + default=[], + help="Run only these query ids (repeatable, e.g. --query-id q01)", + ) + parser.add_argument( + "--router", + choices=[*ROUTERS, "both"], + default="both", + help="Which router(s) to run", + ) + args = parser.parse_args() + + fixture = json.loads(Path(args.fixture).read_text(encoding="utf-8")) + queries = fixture["queries"] + if args.query_id: + allowed = set(args.query_id) + queries = [q for q in queries if q["id"] in allowed] + + routers = list(ROUTERS) if args.router == "both" else [args.router] + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + output_dir = Path(args.output_dir or f"/tmp/agentic_router_eval/{timestamp}") + output_dir.mkdir(parents=True, exist_ok=True) + + user_id = fixture["corpus"]["user_id"] + namespace = fixture["corpus"]["namespace"] + + all_runs: list[RunMetrics] = [] + for item in queries: + for router in routers: + label = f"{item['id']}_{router}" + print(f"▶ {label}: {item['query'][:60]}…", flush=True) + metrics = await _run_one( + user_id=user_id, + namespace=namespace, + query=item["query"], + query_id=item["id"], + router=router, + expected_keywords=item.get("expected_keywords") or [], + ) + all_runs.append(metrics) + print( + f" done {metrics.total_ms}ms refs={metrics.refs} " + f"kw={metrics.keyword_hits}/{metrics.keyword_total} " + f"stop={metrics.stop_reason or metrics.error}", + flush=True, + ) + + report = { + "fixture": args.fixture, + "generated_at": datetime.now().isoformat(timespec="seconds"), + "routers": routers, + "runs": [r.__dict__ for r in all_runs], + } + json_path = output_dir / "eval_report.json" + json_path.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8") + + md = _render_markdown(fixture, all_runs, output_dir) + md_path = output_dir / "eval_report.md" + md_path.write_text(md, encoding="utf-8") + + print(f"\nWrote {json_path}") + print(f"Wrote {md_path}") + print("\n" + md) + + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/config.py b/packages/shared-python/shared/services/retrieval/agent_explore/config.py index a4d0cec1..3daf602a 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/config.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/config.py @@ -95,4 +95,11 @@ `{FINISH_TOOL_NAME}` with your best-effort `refs` (or an empty list plus a `notes` explanation of why nothing was found) rather than continuing to call other tools. + +`refs` is REQUIRED and must not be omitted or left empty if you called +`corpus.read` (or `corpus.assets`) even once during this exploration: copy +the `document_id` and `chunk_id`/`section_path` of every section/chunk you +read that supports your answer into `refs` before calling +`{FINISH_TOOL_NAME}`. Calling `{FINISH_TOOL_NAME}` with no `refs` after +having already read relevant content discards that evidence. """ diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/episode.py b/packages/shared-python/shared/services/retrieval/agent_explore/episode.py index fe1ae0de..4b38acea 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/episode.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/episode.py @@ -16,6 +16,30 @@ within a turn is not implemented here. No import from ``nav/`` or ``nav_config.py`` — see ``config.py``. + +Two Phase 4 fixes (audited live against the eval fixture in +``apps/worker/scripts/fixtures/changheba_archive_eval_queries.json``): + +1. **Stale tool-message collapsing** (``_TOOL_MESSAGE_FRESH_TURNS``, + ``_collapse_stale_tool_messages``): ``messages`` only ever appended, so a + single ``corpus.outline``/``corpus.node_filter`` call (each capped at + ``ToolBudget.max_chars`` — currently ``EVIDENCE_TEXT_CHAR_BUDGET=12_000``, + see ``registry.py``) was resent in full on every later turn. Verified + live: two independent queries (q04, q06 in the eval fixture) hit + ``RETRIEVAL_NAV_TOKEN_LIMIT`` (100k default) within 7-8 LLM turns from + this resend alone, not from query difficulty — per-turn token cost grew + monotonically (q04: 4.4k -> 4.8k -> 19.8k -> 21.5k -> 24.2k -> 29.6k). +2. **Trajectory refs fallback** (``_dedup_refs`` + the fallback at the end of + ``run_agent_explore_episode``): verified live that ``finish`` can be + called with no ``refs`` key at all (raw ``function.arguments`` was + literally ``'{}'``) even after the model had already read clearly + relevant sections via ``corpus.read`` — the ``FINISH_TOOL_SCHEMA``'s + ``"required": ["refs"]`` is a schema hint, not a provider-enforced + constraint. When ``finish``'s own ``refs`` end up empty (whether from + this, from ``no_tool_call``, or from a forced-finish the provider ignored + — all three exit paths), the episode now falls back to the refs already + returned by every ``corpus.read``/``corpus.assets`` call in the + trajectory, deduped, instead of citing nothing. """ from __future__ import annotations @@ -45,6 +69,21 @@ ) from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 +# Tools whose ToolResult.refs point at evidence the agent has actually looked +# at (full body content), as opposed to candidate/listing refs from +# list_documents/outline/node_filter/recall/grep — those describe *where +# things are*, not *what was read*, and would inject unread noise into the +# trajectory-refs fallback below if included. +_EVIDENCE_TOOL_NAMES = frozenset({"corpus.read", "corpus.assets"}) + +# A tool-role message is kept in full for the turn it was produced plus this +# many additional turns, then collapsed to a placeholder — see module +# docstring point 1. Not tuned against a real recall-vs-token tradeoff yet; +# 2 was chosen so a result stays fully visible for one full turn after the +# one it was produced in (enough for the model to act on it immediately), +# revisit with more Phase 4 data. +_TOOL_MESSAGE_FRESH_TURNS = 2 + def _resolve_client_and_model() -> tuple[Any, str]: """Mirrors ``nav_llm_backend.nav_chat_sync_backend``'s resolve pattern, @@ -128,7 +167,13 @@ def _tool_message_content(result: ToolResult, *, max_chars: int) -> str: Uses ``ToolBudget.max_chars`` (``EVIDENCE_TEXT_CHAR_BUDGET``, aligned with map-nav evidence packing) so tools like ``read`` can return unbounded body - text while the harness still bounds what the model sees per turn. + text while the harness still bounds what the model sees per turn. This + cap applies uniformly to every tool's rendered text (not just ``read``'s + body content) — a tool that returns a "complete, non-truncated" *matched + set* by contract (``outline``, ``node_filter`` — see ``registry.py``) + still has its *rendered text* capped here the same as any other tool; + that promise is about payload/refs cardinality, not about how much of it + is shown to the LLM per turn. """ if result.error: return f"error: {result.error}" @@ -138,11 +183,54 @@ def _tool_message_content(result: ToolResult, *, max_chars: int) -> str: omitted = len(text) - max_chars return ( text[:max_chars] - + f"\n...[truncated, {omitted} more chars — call corpus.read again " - "with a narrower/more specific ref if you need the rest]" + + f"\n...[truncated, {omitted} more chars — narrow the scope " + "(e.g. depth/path_prefix for outline, a tighter predicate for " + "node_filter, or a more specific ref for read) and call again if " + "you need the rest]" ) +def _collapse_stale_tool_messages( + messages: list[dict[str, Any]], + tool_message_log: list[dict[str, Any]], + *, + current_turn: int, + fresh_turns: int, +) -> None: + """Replace tool messages older than ``fresh_turns`` with a placeholder. + + ``messages`` only ever grows within one episode (see module docstring + point 1); this is what keeps that growth bounded instead of resending + every past tool result on every later turn. + """ + for entry in tool_message_log: + if entry["collapsed"]: + continue + if current_turn - entry["turn_index"] < fresh_turns: + continue + messages[entry["message_index"]]["content"] = ( + f"[collapsed: {entry['tool_name']} result from turn " + f"{entry['turn_index']} was {entry['original_chars']} chars — " + "call the tool again if you need it back in view]" + ) + entry["collapsed"] = True + + +def _dedup_refs(refs: list[dict[str, Any]]) -> list[dict[str, Any]]: + """Dedup by ``(document_id, chunk_id)``, keeping first-seen order.""" + seen: set[tuple[str, str]] = set() + deduped: list[dict[str, Any]] = [] + for ref in refs: + document_id = str(ref.get("document_id") or "").strip() + chunk_id = str(ref.get("chunk_id") or "").strip() + key = (document_id, chunk_id) + if not document_id or not chunk_id or key in seen: + continue + seen.add(key) + deduped.append(ref) + return deduped + + async def run_agent_explore_episode( *, db: AsyncSession, @@ -166,8 +254,24 @@ async def run_agent_explore_episode( stop_reason = "finished" result_refs: list[dict[str, Any]] = [] result_notes = "" + # Refs from every corpus.read/corpus.assets call this episode, in call + # order — the fallback source when finish's own refs end up empty (see + # module docstring point 2). + trajectory_refs: list[dict[str, Any]] = [] + # One entry per appended tool-role message: {message_index, turn_index, + # tool_name, original_chars, collapsed} — see _collapse_stale_tool_messages. + tool_message_log: list[dict[str, Any]] = [] + turn_index = 0 while True: + turn_index += 1 + _collapse_stale_tool_messages( + messages, + tool_message_log, + current_turn=turn_index, + fresh_turns=_TOOL_MESSAGE_FRESH_TURNS, + ) + forced_reason = budget.exhausted() tool_choice: Any = "auto" if forced_reason is not None: @@ -284,6 +388,17 @@ async def run_agent_explore_episode( messages.append( {"role": "tool", "tool_call_id": tc.id, "content": content} ) + tool_message_log.append( + { + "message_index": len(messages) - 1, + "turn_index": turn_index, + "tool_name": canonical_name, + "original_chars": len(content), + "collapsed": False, + } + ) + if canonical_name in _EVIDENCE_TOOL_NAMES and not tool_result.error: + trajectory_refs.extend(tool_result.refs) # Turn-level token usage is attributed to the first tool step in # this turn (the completion that decided all calls in it); the # rest are 0 to avoid double-counting the same LLM usage. @@ -301,6 +416,15 @@ async def run_agent_explore_episode( ) first_tool_tokens_recorded = True + if not result_refs: + fallback_refs = _dedup_refs(trajectory_refs) + if fallback_refs: + result_refs = fallback_refs + result_notes = (result_notes + " " if result_notes else "") + ( + "[refs auto-filled from corpus.read/corpus.assets trajectory; " + "finish did not cite any]" + ) + return EpisodeResult( refs=result_refs, notes=result_notes, From 605da2bda2b9be84628276ca28abaa130aff1278 Mon Sep 17 00:00:00 2001 From: chengke <404835780@qq.com> Date: Tue, 8 Sep 2026 19:16:40 +0800 Subject: [PATCH 09/15] feat(retrieval): integrate Cursor SDK for agent exploration Added support for the Cursor SDK as an alternative harness for agent exploration. Introduced a new optional dependency, `cursor-sdk`, and updated the agent exploration logic to allow switching between OpenAI-compatible and Cursor SDK providers. Enhanced the `debug_agent_explore_episode` script to accept a `--harness` argument for selecting the desired harness. Updated relevant documentation and configuration to reflect these changes, ensuring clarity on the new harness integration. --- apps/worker/pyproject.toml | 9 + .../scripts/debug_agent_explore_episode.py | 28 +- apps/worker/scripts/debug_finish_raw_args.py | 21 +- .../retrieval/agent_explore/__init__.py | 10 +- .../retrieval/agent_explore/config.py | 9 + .../retrieval/agent_explore/dispatch.py | 56 +++ .../retrieval/agent_explore/episode.py | 435 ------------------ .../agent_explore/harness/__init__.py | 14 + .../retrieval/agent_explore/harness/base.py | 42 ++ .../agent_explore/harness/cursor_harness.py | 298 ++++++++++++ .../agent_explore/harness/openai_harness.py | 383 +++++++++++++++ .../agent_explore/harness/resolve.py | 41 ++ .../retrieval/agent_explore/shared.py | 106 +++++ .../retrieval/agent_tools/registry.py | 2 +- .../services/retrieval/execution/routes.py | 16 +- .../tests/test_agent_explore_harness.py | 195 ++++++++ uv.lock | 23 + 17 files changed, 1222 insertions(+), 466 deletions(-) create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/dispatch.py delete mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/episode.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/harness/__init__.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/harness/base.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/harness/resolve.py create mode 100644 packages/shared-python/shared/services/retrieval/agent_explore/shared.py create mode 100644 packages/shared-python/shared/tests/test_agent_explore_harness.py diff --git a/apps/worker/pyproject.toml b/apps/worker/pyproject.toml index 021eb6f9..5593b776 100644 --- a/apps/worker/pyproject.toml +++ b/apps/worker/pyproject.toml @@ -30,6 +30,15 @@ dependencies = [ "rapidocr-onnxruntime>=1.4.4", ] +# AGENT_EXPLORE_HARNESS=cursor_sdk (shared/services/retrieval/agent_explore/ +# harness/cursor_harness.py). Not in the base dependency set: this harness +# is an alternative to the default OpenAI-compatible one (openai_harness.py), +# not required for it. Install with `uv sync --extra cursor-harness`. +[project.optional-dependencies] +cursor-harness = [ + "cursor-sdk>=1.0.31", +] + [dependency-groups] dev = [ "fakeredis[lua]>=2.31.0", diff --git a/apps/worker/scripts/debug_agent_explore_episode.py b/apps/worker/scripts/debug_agent_explore_episode.py index a74e9928..c85c531f 100644 --- a/apps/worker/scripts/debug_agent_explore_episode.py +++ b/apps/worker/scripts/debug_agent_explore_episode.py @@ -2,9 +2,9 @@ Prints, for each LLM turn / tool call: tool name, args, elapsed ms, tokens_used_delta (turn-level, attributed to the first tool step — see -``episode.py``), tokens_used_total (cumulative), observation length (chars -sent back into the LLM's context), and error. Also prints the final -``EpisodeResult`` (refs/notes/stop_reason). +``harness/openai_harness.py``), tokens_used_total (cumulative), observation +length (chars sent back into the LLM's context), and error. Also prints the +final ``EpisodeResult`` (refs/notes/stop_reason). Read-only diagnostic; does not modify any behavior. @@ -12,6 +12,7 @@ cd apps/worker uv run python scripts/debug_agent_explore_episode.py --query-id q04 uv run python scripts/debug_agent_explore_episode.py --query "..." --token-limit 200000 + uv run python scripts/debug_agent_explore_episode.py --query-id q04 --harness cursor_sdk """ from __future__ import annotations @@ -44,6 +45,7 @@ async def main() -> None: parser.add_argument("--user-id", default="debug_local_user") parser.add_argument("--namespace", default="default") parser.add_argument("--token-limit", type=int, default=None) + parser.add_argument("--harness", default=None, choices=["openai", "cursor_sdk"]) args = parser.parse_args() query = args.query @@ -56,19 +58,19 @@ async def main() -> None: from shared.core.database import get_db_context from shared.services.retrieval.agent_explore.budget import EpisodeBudget - from shared.services.retrieval.agent_explore.episode import run_agent_explore_episode + from shared.services.retrieval.agent_explore.harness import resolve_harness - budget = EpisodeBudget(token_limit=args.token_limit) if args.token_limit else None + budget = EpisodeBudget(token_limit=args.token_limit) if args.token_limit else EpisodeBudget() + harness = resolve_harness(args.harness) print(f"query: {query!r}") - async with get_db_context() as db: - episode = await run_agent_explore_episode( - db=db, - user_id=args.user_id, - namespace=args.namespace, - query=query, - budget=budget, - ) + episode = await harness.run_episode( + db_factory=get_db_context, + user_id=args.user_id, + namespace=args.namespace, + query=query, + budget=budget, + ) print(f"\nstop_reason={episode.stop_reason} tokens_used={episode.tokens_used} " f"model={episode.model_name}") diff --git a/apps/worker/scripts/debug_finish_raw_args.py b/apps/worker/scripts/debug_finish_raw_args.py index 9a6099fe..1d6acfa6 100644 --- a/apps/worker/scripts/debug_finish_raw_args.py +++ b/apps/worker/scripts/debug_finish_raw_args.py @@ -36,26 +36,27 @@ async def main() -> None: match = next(q for q in fixture["queries"] if q["id"] == args.query_id) query = match["query"] - from shared.services.retrieval.agent_explore import episode as episode_mod + from shared.services.retrieval.agent_explore.harness import openai_harness - original_safe_json_loads = episode_mod._safe_json_loads + original_safe_json_loads = openai_harness._safe_json_loads def _spy(raw): print(f"[SPY] raw arguments received: {raw!r}") return original_safe_json_loads(raw) - episode_mod._safe_json_loads = _spy + openai_harness._safe_json_loads = _spy from shared.core.database import get_db_context + from shared.services.retrieval.agent_explore.budget import EpisodeBudget print(f"query: {query!r}") - async with get_db_context() as db: - result = await episode_mod.run_agent_explore_episode( - db=db, - user_id="debug_local_user", - namespace="default", - query=query, - ) + result = await openai_harness.OpenAIHarness().run_episode( + db_factory=get_db_context, + user_id="debug_local_user", + namespace="default", + query=query, + budget=EpisodeBudget(), + ) print(f"\nfinal refs: {result.refs}") print(f"final notes: {result.notes!r}") print(f"stop_reason: {result.stop_reason}") diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py b/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py index f08306a7..8988dbd9 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py @@ -7,6 +7,11 @@ (``execution/routes.py``); ``mapnav`` remains the default until this route passes its Phase 4 evaluation gate. +Which provider runs that loop (OpenAI-compatible/DeepSeek, Cursor SDK) is a +second, independent switch — ``AGENT_EXPLORE_HARNESS`` — resolved via +``resolve_harness()``. See ``harness/`` (Phase 3.5) for the pluggable +``Harness`` interface and its two implementations. + No runtime dependency on ``shared.services.retrieval.nav`` — see ``config.py``'s module docstring. """ @@ -14,12 +19,13 @@ from __future__ import annotations from shared.services.retrieval.agent_explore.budget import EpisodeBudget -from shared.services.retrieval.agent_explore.episode import run_agent_explore_episode +from shared.services.retrieval.agent_explore.harness import Harness, resolve_harness from shared.services.retrieval.agent_explore.types import AgentStep, EpisodeResult __all__ = [ "AgentStep", "EpisodeBudget", "EpisodeResult", - "run_agent_explore_episode", + "Harness", + "resolve_harness", ] diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/config.py b/packages/shared-python/shared/services/retrieval/agent_explore/config.py index 3daf602a..52d5cd87 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/config.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/config.py @@ -22,6 +22,15 @@ AGENT_EXPLORE_MODEL = "deepseek-v4-flash" +# Model for AGENT_EXPLORE_HARNESS=cursor_sdk (harness/cursor_harness.py) — +# a separate constant from AGENT_EXPLORE_MODEL because that harness's +# provider (Cursor SDK) is a disjoint model catalog from the OpenAI-compatible +# client's, not an interchangeable choice. "composer-2.5" is what the PoC +# (apps/worker/scripts/debug_cursor_agent_explore.py) verified live and +# noticeably outperformed deepseek-v4-flash on the two hardest eval-fixture +# queries (q04/q06) — see the Phase 3.5 landing record. +AGENT_EXPLORE_CURSOR_MODEL = "composer-2.5" + # One LLM turn = one round-trip that may contain several parallel tool calls # (see episode.py). Kept low relative to map-nav's per-node dispatch depth # (≤5) because each turn here can already resolve several tools at once. diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/dispatch.py b/packages/shared-python/shared/services/retrieval/agent_explore/dispatch.py new file mode 100644 index 00000000..22621db5 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/dispatch.py @@ -0,0 +1,56 @@ +"""Concurrency-safe per-call tool dispatch shared by every ``agent_explore`` harness. + +Mirrors ``apps/api/app/mcp/dynamic_tools.py``'s ``_dispatch_tool``: SQLAlchemy's +``AsyncSession`` is not safe for concurrent use from multiple coroutines, and a +harness cannot always control whether the orchestrating model issues tool +calls in parallel (verified against the Cursor SDK harness — see +``harness/cursor_harness.py``'s module docstring). Opening a short-lived +session per tool call, instead of sharing one ``AsyncSession`` across the +whole episode, makes dispatch safe regardless of how a harness calls it — +strictly sequential (``harness/openai_harness.py``) or genuinely concurrent +(``harness/cursor_harness.py``). + +This is a behavior change for the OpenAI harness too (previously one shared +session for the whole episode), but a safe one: it already dispatched +sequentially, so a fresh session per call only adds one extra connection +checkout per tool call, never a correctness risk. +""" + +from __future__ import annotations + +from collections.abc import Callable +from contextlib import AbstractAsyncContextManager +from typing import Any + +from sqlalchemy.ext.asyncio import AsyncSession + +from shared.services.retrieval.agent_tools import REGISTRY, ToolBudget, ToolContext, ToolResult + +DbFactory = Callable[[], AbstractAsyncContextManager[AsyncSession]] + + +async def dispatch_tool_call( + name: str, + args: dict[str, Any], + *, + db_factory: DbFactory, + user_id: str, + namespace: str, + budget: ToolBudget | None = None, +) -> ToolResult: + """Run one ``REGISTRY`` tool call against a fresh, call-scoped DB session. + + ``budget`` is forwarded into the ``ToolContext`` built for this one call + (defaults to ``ToolBudget()``, matching prior behavior); callers that need + the same budget value for their own text-capping (``shared.tool_message_content``) + should hold onto the ``ToolBudget`` they pass here rather than reach back + into the (call-scoped, already-closed) ``ToolContext``. + """ + try: + async with db_factory() as db: + tool_ctx = ToolContext( + db=db, user_id=user_id, namespace=namespace, budget=budget or ToolBudget() + ) + return await REGISTRY.dispatch(name, tool_ctx, args) + except Exception as exc: # noqa: BLE001 - one broken tool must not kill the episode + return ToolResult(text="", error=f"{type(exc).__name__}: {exc}") diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/episode.py b/packages/shared-python/shared/services/retrieval/agent_explore/episode.py deleted file mode 100644 index 4b38acea..00000000 --- a/packages/shared-python/shared/services/retrieval/agent_explore/episode.py +++ /dev/null @@ -1,435 +0,0 @@ -"""In-process tool-calling episode over the ``agent_tools`` corpus registry. - -Uses ``OpenAICompatibleClientSync.chat_completion_raw_with_usage`` — the RAW -response, not ``chat_completion_with_usage`` — because the latter only -returns ``.content`` and silently drops ``message.tool_calls``. Verified live -(2026-09-08) against ``deepseek-v4-flash`` via this codebase's client: -single tool call, parallel tool calls in one turn, tool-result feedback + -final synthesis, and forced ``tool_choice`` (used for the budget-exhaustion -cutoff below) all work. - -Tool calls within one turn are dispatched sequentially against the single -shared ``ToolContext.db`` (``AsyncSession``), not via ``asyncio.gather``: -SQLAlchemy's ``AsyncSession`` is not safe for concurrent use from multiple -coroutines. Batching several tool calls into one LLM turn already removes -the LLM round-trip per tool (the dominant cost); true DB-level concurrency -within a turn is not implemented here. - -No import from ``nav/`` or ``nav_config.py`` — see ``config.py``. - -Two Phase 4 fixes (audited live against the eval fixture in -``apps/worker/scripts/fixtures/changheba_archive_eval_queries.json``): - -1. **Stale tool-message collapsing** (``_TOOL_MESSAGE_FRESH_TURNS``, - ``_collapse_stale_tool_messages``): ``messages`` only ever appended, so a - single ``corpus.outline``/``corpus.node_filter`` call (each capped at - ``ToolBudget.max_chars`` — currently ``EVIDENCE_TEXT_CHAR_BUDGET=12_000``, - see ``registry.py``) was resent in full on every later turn. Verified - live: two independent queries (q04, q06 in the eval fixture) hit - ``RETRIEVAL_NAV_TOKEN_LIMIT`` (100k default) within 7-8 LLM turns from - this resend alone, not from query difficulty — per-turn token cost grew - monotonically (q04: 4.4k -> 4.8k -> 19.8k -> 21.5k -> 24.2k -> 29.6k). -2. **Trajectory refs fallback** (``_dedup_refs`` + the fallback at the end of - ``run_agent_explore_episode``): verified live that ``finish`` can be - called with no ``refs`` key at all (raw ``function.arguments`` was - literally ``'{}'``) even after the model had already read clearly - relevant sections via ``corpus.read`` — the ``FINISH_TOOL_SCHEMA``'s - ``"required": ["refs"]`` is a schema hint, not a provider-enforced - constraint. When ``finish``'s own ``refs`` end up empty (whether from - this, from ``no_tool_call``, or from a forced-finish the provider ignored - — all three exit paths), the episode now falls back to the refs already - returned by every ``corpus.read``/``corpus.assets`` call in the - trajectory, deduped, instead of citing nothing. -""" - -from __future__ import annotations - -import asyncio -import json -import time -from typing import Any - -from sqlalchemy.ext.asyncio import AsyncSession - -from shared.services.retrieval.agent_explore.budget import EpisodeBudget -from shared.services.retrieval.agent_explore.config import ( - AGENT_EXPLORE_MAX_COMPLETION_TOKENS, - AGENT_EXPLORE_MODEL, - FINISH_TOOL_DESCRIPTION, - FINISH_TOOL_NAME, - FINISH_TOOL_SCHEMA, - LOOP_CONTRACT_SUFFIX, -) -from shared.services.retrieval.agent_explore.types import AgentStep, EpisodeResult -from shared.services.retrieval.agent_tools import ( - REGISTRY, - ToolContext, - ToolResult, - load_corpus_schema_text, -) -from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 - -# Tools whose ToolResult.refs point at evidence the agent has actually looked -# at (full body content), as opposed to candidate/listing refs from -# list_documents/outline/node_filter/recall/grep — those describe *where -# things are*, not *what was read*, and would inject unread noise into the -# trajectory-refs fallback below if included. -_EVIDENCE_TOOL_NAMES = frozenset({"corpus.read", "corpus.assets"}) - -# A tool-role message is kept in full for the turn it was produced plus this -# many additional turns, then collapsed to a placeholder — see module -# docstring point 1. Not tuned against a real recall-vs-token tradeoff yet; -# 2 was chosen so a result stays fully visible for one full turn after the -# one it was produced in (enough for the model to act on it immediately), -# revisit with more Phase 4 data. -_TOOL_MESSAGE_FRESH_TURNS = 2 - - -def _resolve_client_and_model() -> tuple[Any, str]: - """Mirrors ``nav_llm_backend.nav_chat_sync_backend``'s resolve pattern, - pinned to ``AGENT_EXPLORE_MODEL`` instead of ``nav_config.MAPNAV_MODEL``. - """ - from shared.services.ai.llm_overrides import resolve_text - from shared.services.ai.openai_compatible_client_sync import get_openai_client - - requested = AGENT_EXPLORE_MODEL - effective_model, api_key, api_url = resolve_text(requested) - model = effective_model or requested - client = get_openai_client(model=model, api_key=api_key, api_url=api_url) - return client, model - - -def _openai_safe_name(name: str) -> str: - """DeepSeek's (OpenAI-compatible) function-calling API rejects ``.`` in - ``tools[].function.name`` (must match ``^[a-zA-Z0-9_-]+$``, verified - live), but every ``agent_tools`` name is dotted (``corpus.read``) and - that's also what MCP clients see (no such restriction there) — so the - dotted name stays canonical in ``REGISTRY``/MCP, and this harness-local - underscore form exists only for the wire format to this one provider. - """ - return name.replace(".", "_") - - -def _build_openai_tools() -> tuple[list[dict[str, Any]], dict[str, str]]: - """Return ``(tools, name_map)`` where ``name_map`` maps the OpenAI-safe - name back to the canonical ``REGISTRY`` name (``finish`` maps to itself). - """ - name_map: dict[str, str] = {FINISH_TOOL_NAME: FINISH_TOOL_NAME} - tools: list[dict[str, Any]] = [] - for spec in REGISTRY.all(): - safe_name = _openai_safe_name(spec.name) - name_map[safe_name] = spec.name - tools.append( - { - "type": "function", - "function": { - "name": safe_name, - "description": spec.description, - "parameters": spec.json_schema, - }, - } - ) - tools.append( - { - "type": "function", - "function": { - "name": FINISH_TOOL_NAME, - "description": FINISH_TOOL_DESCRIPTION, - "parameters": FINISH_TOOL_SCHEMA, - }, - } - ) - return tools, name_map - - -def _safe_json_loads(raw: str | None) -> dict[str, Any]: - if not raw: - return {} - try: - parsed = json.loads(raw) - except (TypeError, ValueError): - return {} - return parsed if isinstance(parsed, dict) else {} - - -def _normalize_finish_refs(raw: Any) -> list[dict[str, Any]]: - if not isinstance(raw, list): - return [] - normalized: list[dict[str, Any]] = [] - for item in raw: - if isinstance(item, dict) and str(item.get("document_id") or "").strip(): - normalized.append(item) - return normalized - - -def _tool_message_content(result: ToolResult, *, max_chars: int) -> str: - """Cap a tool's rendered text before it enters LLM context. - - Uses ``ToolBudget.max_chars`` (``EVIDENCE_TEXT_CHAR_BUDGET``, aligned with - map-nav evidence packing) so tools like ``read`` can return unbounded body - text while the harness still bounds what the model sees per turn. This - cap applies uniformly to every tool's rendered text (not just ``read``'s - body content) — a tool that returns a "complete, non-truncated" *matched - set* by contract (``outline``, ``node_filter`` — see ``registry.py``) - still has its *rendered text* capped here the same as any other tool; - that promise is about payload/refs cardinality, not about how much of it - is shown to the LLM per turn. - """ - if result.error: - return f"error: {result.error}" - text = result.text or "(empty result)" - if len(text) <= max_chars: - return text - omitted = len(text) - max_chars - return ( - text[:max_chars] - + f"\n...[truncated, {omitted} more chars — narrow the scope " - "(e.g. depth/path_prefix for outline, a tighter predicate for " - "node_filter, or a more specific ref for read) and call again if " - "you need the rest]" - ) - - -def _collapse_stale_tool_messages( - messages: list[dict[str, Any]], - tool_message_log: list[dict[str, Any]], - *, - current_turn: int, - fresh_turns: int, -) -> None: - """Replace tool messages older than ``fresh_turns`` with a placeholder. - - ``messages`` only ever grows within one episode (see module docstring - point 1); this is what keeps that growth bounded instead of resending - every past tool result on every later turn. - """ - for entry in tool_message_log: - if entry["collapsed"]: - continue - if current_turn - entry["turn_index"] < fresh_turns: - continue - messages[entry["message_index"]]["content"] = ( - f"[collapsed: {entry['tool_name']} result from turn " - f"{entry['turn_index']} was {entry['original_chars']} chars — " - "call the tool again if you need it back in view]" - ) - entry["collapsed"] = True - - -def _dedup_refs(refs: list[dict[str, Any]]) -> list[dict[str, Any]]: - """Dedup by ``(document_id, chunk_id)``, keeping first-seen order.""" - seen: set[tuple[str, str]] = set() - deduped: list[dict[str, Any]] = [] - for ref in refs: - document_id = str(ref.get("document_id") or "").strip() - chunk_id = str(ref.get("chunk_id") or "").strip() - key = (document_id, chunk_id) - if not document_id or not chunk_id or key in seen: - continue - seen.add(key) - deduped.append(ref) - return deduped - - -async def run_agent_explore_episode( - *, - db: AsyncSession, - user_id: str, - namespace: str, - query: str, - budget: EpisodeBudget | None = None, -) -> EpisodeResult: - budget = budget or EpisodeBudget() - tool_ctx = ToolContext(db=db, user_id=user_id, namespace=namespace) - client, model = _resolve_client_and_model() - openai_tools, tool_name_map = _build_openai_tools() - - system_prompt = load_corpus_schema_text() + LOOP_CONTRACT_SUFFIX - messages: list[dict[str, Any]] = [ - {"role": "system", "content": system_prompt}, - {"role": "user", "content": query}, - ] - - steps: list[AgentStep] = [] - stop_reason = "finished" - result_refs: list[dict[str, Any]] = [] - result_notes = "" - # Refs from every corpus.read/corpus.assets call this episode, in call - # order — the fallback source when finish's own refs end up empty (see - # module docstring point 2). - trajectory_refs: list[dict[str, Any]] = [] - # One entry per appended tool-role message: {message_index, turn_index, - # tool_name, original_chars, collapsed} — see _collapse_stale_tool_messages. - tool_message_log: list[dict[str, Any]] = [] - turn_index = 0 - - while True: - turn_index += 1 - _collapse_stale_tool_messages( - messages, - tool_message_log, - current_turn=turn_index, - fresh_turns=_TOOL_MESSAGE_FRESH_TURNS, - ) - - forced_reason = budget.exhausted() - tool_choice: Any = "auto" - if forced_reason is not None: - tool_choice = {"type": "function", "function": {"name": FINISH_TOOL_NAME}} - - turn_started = time.perf_counter() - response, usage = await asyncio.to_thread( - client.chat_completion_raw_with_usage, - messages=messages, - model=model, - temperature=0.0, - max_tokens=AGENT_EXPLORE_MAX_COMPLETION_TOKENS, - tools=openai_tools, - tool_choice=tool_choice, - ) - budget.record_usage(usage) - budget.record_step() - turn_elapsed_ms = int((time.perf_counter() - turn_started) * 1000) - turn_tokens = int((usage or {}).get("total_tokens", 0) or 0) - - message = response.choices[0].message - tool_calls = list(message.tool_calls or []) - - if not tool_calls: - stop_reason = f"budget_{forced_reason}" if forced_reason else "no_tool_call" - result_notes = str(message.content or "") - steps.append( - AgentStep( - step_index=len(steps), - tool_name="", - tool_args={}, - observation_text=result_notes, - error=None, - elapsed_ms=turn_elapsed_ms, - tokens_used_delta=turn_tokens, - tokens_used_total=budget.tokens_used, - ) - ) - break - - finish_call = next( - (tc for tc in tool_calls if tc.function.name == FINISH_TOOL_NAME), None - ) - if finish_call is not None: - args = _safe_json_loads(finish_call.function.arguments) - result_refs = _normalize_finish_refs(args.get("refs")) - result_notes = str(args.get("notes") or "") - stop_reason = f"budget_{forced_reason}" if forced_reason else "finished" - steps.append( - AgentStep( - step_index=len(steps), - tool_name=FINISH_TOOL_NAME, - tool_args=args, - observation_text=f"refs={len(result_refs)} notes={result_notes!r}", - error=None, - elapsed_ms=turn_elapsed_ms, - tokens_used_delta=turn_tokens, - tokens_used_total=budget.tokens_used, - ) - ) - break - - if forced_reason is not None: - # Forced tool_choice=finish but the provider returned a - # different tool anyway (not observed in verification, but a - # budget cutoff must never loop past). Stop here regardless. - stop_reason = f"budget_{forced_reason}" - result_notes = str(message.content or "") or ( - "budget exhausted; provider did not return finish" - ) - steps.append( - AgentStep( - step_index=len(steps), - tool_name="", - tool_args={}, - observation_text=result_notes, - error="forced_finish_not_honored", - elapsed_ms=turn_elapsed_ms, - tokens_used_delta=turn_tokens, - tokens_used_total=budget.tokens_used, - ) - ) - break - - messages.append( - { - "role": "assistant", - "content": message.content or "", - "tool_calls": [ - { - "id": tc.id, - "type": "function", - "function": { - "name": tc.function.name, - "arguments": tc.function.arguments, - }, - } - for tc in tool_calls - ], - } - ) - first_tool_tokens_recorded = False - for tc in tool_calls: - tool_started = time.perf_counter() - args = _safe_json_loads(tc.function.arguments) - requested_name = str(tc.function.name or "") - canonical_name = tool_name_map.get(requested_name, requested_name) - try: - tool_result = await REGISTRY.dispatch(canonical_name, tool_ctx, args) - except Exception as exc: # noqa: BLE001 - one broken tool must not kill the episode - tool_result = ToolResult(text="", error=f"{type(exc).__name__}: {exc}") - tool_elapsed_ms = int((time.perf_counter() - tool_started) * 1000) - content = _tool_message_content(tool_result, max_chars=tool_ctx.budget.max_chars) - messages.append( - {"role": "tool", "tool_call_id": tc.id, "content": content} - ) - tool_message_log.append( - { - "message_index": len(messages) - 1, - "turn_index": turn_index, - "tool_name": canonical_name, - "original_chars": len(content), - "collapsed": False, - } - ) - if canonical_name in _EVIDENCE_TOOL_NAMES and not tool_result.error: - trajectory_refs.extend(tool_result.refs) - # Turn-level token usage is attributed to the first tool step in - # this turn (the completion that decided all calls in it); the - # rest are 0 to avoid double-counting the same LLM usage. - steps.append( - AgentStep( - step_index=len(steps), - tool_name=canonical_name, - tool_args=args, - observation_text=content, - error=tool_result.error, - elapsed_ms=tool_elapsed_ms if first_tool_tokens_recorded else turn_elapsed_ms + tool_elapsed_ms, - tokens_used_delta=0 if first_tool_tokens_recorded else turn_tokens, - tokens_used_total=budget.tokens_used, - ) - ) - first_tool_tokens_recorded = True - - if not result_refs: - fallback_refs = _dedup_refs(trajectory_refs) - if fallback_refs: - result_refs = fallback_refs - result_notes = (result_notes + " " if result_notes else "") + ( - "[refs auto-filled from corpus.read/corpus.assets trajectory; " - "finish did not cite any]" - ) - - return EpisodeResult( - refs=result_refs, - notes=result_notes, - steps=steps, - stop_reason=stop_reason, - tokens_used=budget.tokens_used, - model_name=model, - ) diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/__init__.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/__init__.py new file mode 100644 index 00000000..e4559f30 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/__init__.py @@ -0,0 +1,14 @@ +"""Pluggable ``agent_explore`` harness implementations. + +``base.Harness`` is the provider-agnostic interface; ``openai_harness`` and +``cursor_harness`` are the two implementations selected via +``AGENT_EXPLORE_HARNESS`` (``execution/routes.py``). See the Phase 3.5 +section of ``.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md``. +""" + +from __future__ import annotations + +from shared.services.retrieval.agent_explore.harness.base import Harness +from shared.services.retrieval.agent_explore.harness.resolve import resolve_harness + +__all__ = ["Harness", "resolve_harness"] diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/base.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/base.py new file mode 100644 index 00000000..45c236f7 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/base.py @@ -0,0 +1,42 @@ +"""Provider-agnostic ``Harness`` interface for ``agent_explore``. + +Any backend-hosted tool-loop implementation (OpenAI-compatible/DeepSeek, +Cursor SDK, ...) implements this single method. ``_run_agent_explore_route`` +(``execution/routes.py``) resolves one ``Harness`` via ``AGENT_EXPLORE_HARNESS`` +(see ``harness/resolve.py``) and calls it the same way regardless of which +provider is behind it — the route/bridge/budget-object shapes do not change +per harness. +""" + +from __future__ import annotations + +from typing import Protocol, runtime_checkable + +from shared.services.retrieval.agent_explore.budget import EpisodeBudget +from shared.services.retrieval.agent_explore.dispatch import DbFactory +from shared.services.retrieval.agent_explore.types import EpisodeResult + + +@runtime_checkable +class Harness(Protocol): + """One backend-hosted tool-loop implementation over ``agent_tools.REGISTRY``.""" + + async def run_episode( + self, + *, + db_factory: DbFactory, + user_id: str, + namespace: str, + query: str, + budget: EpisodeBudget, + ) -> EpisodeResult: + """Explore the corpus for ``query`` and return the cited evidence. + + ``db_factory`` is a call-scoped DB session factory (see + ``dispatch.py``) — implementations must not hold one shared + ``AsyncSession`` across the whole episode; every ``REGISTRY.dispatch`` + call goes through ``dispatch.dispatch_tool_call(..., db_factory=db_factory)`` + so concurrent tool calls (a real Cursor SDK behavior, not just a + theoretical one — see ``harness/cursor_harness.py``) are always safe. + """ + ... diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py new file mode 100644 index 00000000..f4436518 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py @@ -0,0 +1,298 @@ +"""``Harness`` implementation over the Cursor SDK local agent. + +Promoted from ``apps/worker/scripts/debug_cursor_agent_explore.py`` (PoC) — +see Phase 3.5 of +``.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md``. Uses +``cursor_sdk``'s ``local.custom_tools`` so this host process still executes +``agent_tools.REGISTRY`` (same ``corpus.*`` tools as ``harness/openai_harness.py``), +while the orchestration model comes from Cursor (default +``config.AGENT_EXPLORE_CURSOR_MODEL``, e.g. ``composer-2.5``) instead of +DeepSeek. + +Requires the optional ``cursor-sdk`` dependency (see +``apps/worker/pyproject.toml``'s ``cursor-harness`` extra) and +``CURSOR_API_KEY``. The guarded import in ``_require_cursor_sdk`` raises a +clear, actionable error at harness-selection time if ``cursor-sdk`` isn't +installed, instead of failing deep inside a running episode. + +Architectural difference from ``openai_harness.py`` that budget enforcement +has to work around: this harness does not control the LLM turn loop. +``agent.send(...)`` + ``await run.wait()`` hands the *entire* multi-turn +tool-calling loop to the Cursor SDK; the host process only sees (a) +``execute`` callbacks for each ``corpus.*``/``finish`` tool call — run +synchronously off the SDK's own thread and bridged back onto this event +loop via ``asyncio.run_coroutine_threadsafe`` (mirrors the PoC's +``_dispatch_sync``) — and (b) the terminal ``RunResult`` once ``wait()`` +returns. There is no per-turn hook to inspect budget mid-turn and force +``tool_choice`` the way ``openai_harness.py`` does. Each budget dimension is +therefore enforced (or explicitly not) differently here: + +- **``max_steps``**: a plain counter (``budget.steps_used``, incremented once + per ``corpus.*`` dispatch — ``finish`` does not count, it ends the episode + on its own) checked in ``_dispatch_sync`` *before* dispatching. Once the + counter reaches ``budget.max_steps``, further ``corpus.*`` calls are not + forwarded to ``REGISTRY`` at all — the callback returns a fixed + "budget exhausted, call finish now" string instead. This is a real, + synchronous cutoff (unlike the two dimensions below): no reliance on + cancelling the SDK run from a background task. +- **``wall_clock``**: ``asyncio.wait_for(run.wait(), timeout=budget.wall_clock_seconds)``, + per the plan. On timeout, best-effort ``await run.cancel()`` (own short + timeout, so a hung cancel RPC can't hang this call forever) so the + underlying agent run actually stops server-side instead of merely being + abandoned by this process, then the episode result is built from whatever + ``finish``/tool-trajectory refs were captured before the timeout. +- **``token_limit``**: **not actively enforced mid-run.** Verified by reading + the installed ``cursor-sdk`` package's source + (``cursor_sdk._run_base._RunBase.usage``, 2026-09) that cumulative token + usage is incrementally accumulated from ``SDKUsageMessage`` stream events + as ``run.wait()`` consumes them, and exposed as a live ``run.usage`` + property — so a mid-run cutoff (e.g. a polling task calling + ``run.cancel()``) is *plausible*. It was **not** exercised against a real + ``CURSOR_API_KEY`` run in this change (no key available in the + implementation environment), so building an active cutoff on top of an + unverified live-update assumption was judged higher-risk than shipping. + ``EpisodeBudget.exhausted()``'s ``token_limit`` dimension is therefore left + unchecked here by design; ``budget.tokens_used`` is only populated + *post-hoc* from the terminal ``RunResult.usage`` for observability + (``EpisodeResult.tokens_used``), after the episode has already finished. + If ``eval-cursor-harness`` confirms ``run.usage`` does update live against + a real key, promoting this to an active cutoff (mirroring the + ``max_steps``/``wall_clock`` pattern above) is straightforward follow-up + work — deliberately not done speculatively here. +""" + +from __future__ import annotations + +import asyncio +import contextlib +import json +import os +import time +from typing import Any + +from shared.services.retrieval.agent_explore.budget import EpisodeBudget +from shared.services.retrieval.agent_explore.config import ( + AGENT_EXPLORE_CURSOR_MODEL, + FINISH_TOOL_DESCRIPTION, + FINISH_TOOL_NAME, + FINISH_TOOL_SCHEMA, + LOOP_CONTRACT_SUFFIX, +) +from shared.services.retrieval.agent_explore.dispatch import DbFactory, dispatch_tool_call +from shared.services.retrieval.agent_explore.shared import ( + EVIDENCE_TOOL_NAMES, + dedup_refs, + normalize_finish_refs, + tool_message_content, + wire_safe_tool_name, +) +from shared.services.retrieval.agent_explore.types import AgentStep, EpisodeResult +from shared.services.retrieval.agent_tools import ( + REGISTRY, + ToolBudget, + ToolResult, + load_corpus_schema_text, +) +from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 + +# Grace period for the underlying agent run to actually stop, after a +# best-effort run.cancel() following a wall_clock timeout, before this +# process gives up waiting for a terminal RunResult and falls back to +# whatever refs the trajectory already captured. Not tuned against real +# cancel-RPC latency yet (no CURSOR_API_KEY in the implementation +# environment) — revisit with eval-cursor-harness data. +_CANCEL_GRACE_SECONDS = 30.0 + +_BUDGET_EXHAUSTED_MESSAGE = ( + "error: step budget exhausted for this episode — do not call any more " + "corpus.* tools; call finish now with whatever refs you already have " + "(or an empty list plus a notes explanation)." +) + + +def _require_cursor_sdk() -> Any: + try: + import cursor_sdk + except ImportError as exc: + raise RuntimeError( + "AGENT_EXPLORE_HARNESS=cursor_sdk requires the optional " + "'cursor-sdk' dependency, which is not installed in this " + "interpreter. Install with: uv sync --extra cursor-harness " + "(apps/worker/pyproject.toml)." + ) from exc + return cursor_sdk + + +class CursorHarness: + """``Harness`` implementation over the Cursor SDK local agent.""" + + def __init__(self, *, model: str | None = None) -> None: + self._model = model or AGENT_EXPLORE_CURSOR_MODEL + + async def run_episode( + self, + *, + db_factory: DbFactory, + user_id: str, + namespace: str, + query: str, + budget: EpisodeBudget, + ) -> EpisodeResult: + cursor_sdk = _require_cursor_sdk() + + api_key = os.environ.get("CURSOR_API_KEY", "").strip() + if not api_key: + raise RuntimeError( + "AGENT_EXPLORE_HARNESS=cursor_sdk requires CURSOR_API_KEY to be set" + ) + + tool_budget = ToolBudget() + loop = asyncio.get_running_loop() + + steps: list[AgentStep] = [] + trajectory_refs: list[dict[str, Any]] = [] + # None until finish is actually called — distinguishes "finish + # called with an empty refs list" (respect it) from "finish never + # called" (fall back to trajectory_refs below), same contract as + # openai_harness.py's normalize_finish_refs + fallback. + finish_state: dict[str, Any] = {"refs": None, "notes": ""} + stop_reason = "finished" + + def _dispatch_sync(tool_name: str, args: dict[str, Any]) -> str: + if budget.steps_used >= budget.max_steps: + steps.append( + AgentStep( + step_index=len(steps), + tool_name=tool_name, + tool_args=args, + observation_text=_BUDGET_EXHAUSTED_MESSAGE, + error="budget_max_steps", + elapsed_ms=0, + tokens_used_delta=0, + tokens_used_total=budget.tokens_used, + ) + ) + return _BUDGET_EXHAUSTED_MESSAGE + budget.record_step() + tool_started = time.perf_counter() + future = asyncio.run_coroutine_threadsafe( + dispatch_tool_call( + tool_name, + args, + db_factory=db_factory, + user_id=user_id, + namespace=namespace, + budget=tool_budget, + ), + loop, + ) + try: + tool_result = future.result(timeout=180) + except Exception as exc: # noqa: BLE001 - one broken tool must not kill the episode + tool_result = ToolResult(text="", error=f"{type(exc).__name__}: {exc}") + elapsed_ms = int((time.perf_counter() - tool_started) * 1000) + content = tool_message_content(tool_result, max_chars=tool_budget.max_chars) + steps.append( + AgentStep( + step_index=len(steps), + tool_name=tool_name, + tool_args=args, + observation_text=content, + error=tool_result.error, + elapsed_ms=elapsed_ms, + tokens_used_delta=0, + tokens_used_total=budget.tokens_used, + ) + ) + if tool_name in EVIDENCE_TOOL_NAMES and not tool_result.error: + trajectory_refs.extend(tool_result.refs) + return content + + custom_tools: dict[str, Any] = {} + for spec in REGISTRY.all(): + wire_name = wire_safe_tool_name(spec.name) + + def _make_execute(resolved_name: str): + def execute(args: dict[str, Any], _ctx: Any) -> str: + return _dispatch_sync(resolved_name, dict(args or {})) + + return execute + + custom_tools[wire_name] = cursor_sdk.CustomTool( + execute=_make_execute(spec.name), + description=f"{spec.description} (canonical name: {spec.name})", + input_schema=spec.json_schema, + ) + + def finish_execute(args: dict[str, Any], _ctx: Any) -> str: + finish_state["refs"] = normalize_finish_refs(args.get("refs")) + finish_state["notes"] = str(args.get("notes") or "") + return json.dumps({"status": "finished", "refs": len(finish_state["refs"])}) + + custom_tools[FINISH_TOOL_NAME] = cursor_sdk.CustomTool( + execute=finish_execute, + description=FINISH_TOOL_DESCRIPTION, + input_schema=FINISH_TOOL_SCHEMA, + ) + + system_prompt = load_corpus_schema_text() + LOOP_CONTRACT_SUFFIX + user_prompt = ( + f"{system_prompt}\n\n---\n\nUser query:\n{query}\n\n" + "Tool names on the wire use underscores " + f"({', '.join(sorted(custom_tools))}). Explore with those tools, " + "then call finish with cited refs." + ) + + result: Any = None + async with await cursor_sdk.AsyncClient.launch_bridge( + workspace=os.getcwd(), + ) as client: + async with await client.agents.create( + cursor_sdk.AgentOptions( + api_key=api_key, + model=self._model, + local=cursor_sdk.LocalAgentOptions( + cwd=os.getcwd(), + custom_tools=custom_tools, + ), + ) + ) as agent: + run = await agent.send(user_prompt) + try: + result = await asyncio.wait_for( + run.wait(), timeout=budget.wall_clock_seconds + ) + except asyncio.TimeoutError: + stop_reason = "budget_wall_clock" + with contextlib.suppress(Exception): + await asyncio.wait_for(run.cancel(), timeout=10) + with contextlib.suppress(Exception): + result = await asyncio.wait_for( + run.wait(), timeout=_CANCEL_GRACE_SECONDS + ) + + result_usage_total_tokens = 0 + if result is not None and result.usage is not None: + result_usage_total_tokens = result.usage.total_tokens + budget.record_usage({"total_tokens": result_usage_total_tokens}) + + result_refs = finish_state["refs"] + result_notes = str(finish_state["notes"] or "") + if not result_refs: + fallback_refs = dedup_refs(trajectory_refs) + if fallback_refs: + result_refs = fallback_refs + result_notes = (result_notes + " " if result_notes else "") + ( + "[refs auto-filled from corpus.read/corpus.assets trajectory; " + "finish did not cite any]" + ) + result_refs = result_refs or [] + + return EpisodeResult( + refs=result_refs, + notes=result_notes, + steps=steps, + stop_reason=stop_reason, + tokens_used=budget.tokens_used, + model_name=self._model, + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py new file mode 100644 index 00000000..dd8df212 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py @@ -0,0 +1,383 @@ +"""In-process tool-calling episode over the ``agent_tools`` corpus registry, +via an OpenAI-compatible (DeepSeek) function-calling loop. + +Uses ``OpenAICompatibleClientSync.chat_completion_raw_with_usage`` — the RAW +response, not ``chat_completion_with_usage`` — because the latter only +returns ``.content`` and silently drops ``message.tool_calls``. Verified live +(2026-09-08) against ``deepseek-v4-flash`` via this codebase's client: +single tool call, parallel tool calls in one turn, tool-result feedback + +final synthesis, and forced ``tool_choice`` (used for the budget-exhaustion +cutoff below) all work. + +Tool calls within one turn are dispatched sequentially through +``dispatch.dispatch_tool_call`` (fresh DB session per call — safe for any +harness, not just this one), not via ``asyncio.gather``: batching several +tool calls into one LLM turn already removes the LLM round-trip per tool +(the dominant cost); true DB-level concurrency within a turn is not +implemented here since this provider's tool calls are handled one at a time +by design, not because concurrent dispatch would be unsafe (it no longer is +— see ``dispatch.py``). + +No import from ``nav/`` or ``nav_config.py`` — see ``config.py``. + +Two Phase 4 fixes (audited live against the eval fixture in +``apps/worker/scripts/fixtures/changheba_archive_eval_queries.json``), both +now shared with any other harness via ``shared.py`` except stale-message +collapsing (fix 1), which stays here — it mutates this harness's own +``messages: list[dict]`` history, a mechanism the Cursor SDK harness has no +equivalent hook for: + +1. **Stale tool-message collapsing** (``_TOOL_MESSAGE_FRESH_TURNS``, + ``_collapse_stale_tool_messages``): ``messages`` only ever appended, so a + single ``corpus.outline``/``corpus.node_filter`` call (each capped at + ``ToolBudget.max_chars`` — currently ``EVIDENCE_TEXT_CHAR_BUDGET=12_000``, + see ``registry.py``) was resent in full on every later turn. Verified + live: two independent queries (q04, q06 in the eval fixture) hit + ``RETRIEVAL_NAV_TOKEN_LIMIT`` (100k default) within 7-8 LLM turns from + this resend alone, not from query difficulty — per-turn token cost grew + monotonically (q04: 4.4k -> 4.8k -> 19.8k -> 21.5k -> 24.2k -> 29.6k). +2. **Trajectory refs fallback** (``shared.dedup_refs`` + the fallback at the + end of ``run_episode``): verified live that ``finish`` can be called with + no ``refs`` key at all (raw ``function.arguments`` was literally ``'{}'``) + even after the model had already read clearly relevant sections via + ``corpus.read`` — the ``FINISH_TOOL_SCHEMA``'s ``"required": ["refs"]`` is + a schema hint, not a provider-enforced constraint. When ``finish``'s own + ``refs`` end up empty (whether from this, from ``no_tool_call``, or from a + forced-finish the provider ignored — all three exit paths), the episode + now falls back to the refs already returned by every + ``corpus.read``/``corpus.assets`` call in the trajectory, deduped, instead + of citing nothing. +""" + +from __future__ import annotations + +import asyncio +import json +import time +from typing import Any + +from shared.services.retrieval.agent_explore.budget import EpisodeBudget +from shared.services.retrieval.agent_explore.config import ( + AGENT_EXPLORE_MAX_COMPLETION_TOKENS, + AGENT_EXPLORE_MODEL, + FINISH_TOOL_DESCRIPTION, + FINISH_TOOL_NAME, + FINISH_TOOL_SCHEMA, + LOOP_CONTRACT_SUFFIX, +) +from shared.services.retrieval.agent_explore.dispatch import DbFactory, dispatch_tool_call +from shared.services.retrieval.agent_explore.shared import ( + EVIDENCE_TOOL_NAMES, + build_wire_tool_name_map, + dedup_refs, + normalize_finish_refs, + tool_message_content, + wire_safe_tool_name, +) +from shared.services.retrieval.agent_explore.types import AgentStep, EpisodeResult +from shared.services.retrieval.agent_tools import REGISTRY, ToolBudget, load_corpus_schema_text +from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 + +# A tool-role message is kept in full for the turn it was produced plus this +# many additional turns, then collapsed to a placeholder — see module +# docstring point 1. Not tuned against a real recall-vs-token tradeoff yet; +# 2 was chosen so a result stays fully visible for one full turn after the +# one it was produced in (enough for the model to act on it immediately), +# revisit with more Phase 4 data. +_TOOL_MESSAGE_FRESH_TURNS = 2 + + +def _resolve_client_and_model() -> tuple[Any, str]: + """Mirrors ``nav_llm_backend.nav_chat_sync_backend``'s resolve pattern, + pinned to ``AGENT_EXPLORE_MODEL`` instead of ``nav_config.MAPNAV_MODEL``. + """ + from shared.services.ai.llm_overrides import resolve_text + from shared.services.ai.openai_compatible_client_sync import get_openai_client + + requested = AGENT_EXPLORE_MODEL + effective_model, api_key, api_url = resolve_text(requested) + model = effective_model or requested + client = get_openai_client(model=model, api_key=api_key, api_url=api_url) + return client, model + + +def _build_openai_tools() -> tuple[list[dict[str, Any]], dict[str, str]]: + """Return ``(tools, name_map)`` where ``name_map`` maps the wire-safe + name back to the canonical ``REGISTRY`` name (``finish`` maps to itself). + """ + specs = REGISTRY.all() + name_map = build_wire_tool_name_map([spec.name for spec in specs]) + name_map[FINISH_TOOL_NAME] = FINISH_TOOL_NAME + tools: list[dict[str, Any]] = [ + { + "type": "function", + "function": { + "name": wire_safe_tool_name(spec.name), + "description": spec.description, + "parameters": spec.json_schema, + }, + } + for spec in specs + ] + tools.append( + { + "type": "function", + "function": { + "name": FINISH_TOOL_NAME, + "description": FINISH_TOOL_DESCRIPTION, + "parameters": FINISH_TOOL_SCHEMA, + }, + } + ) + return tools, name_map + + +def _safe_json_loads(raw: str | None) -> dict[str, Any]: + if not raw: + return {} + try: + parsed = json.loads(raw) + except (TypeError, ValueError): + return {} + return parsed if isinstance(parsed, dict) else {} + + +def _collapse_stale_tool_messages( + messages: list[dict[str, Any]], + tool_message_log: list[dict[str, Any]], + *, + current_turn: int, + fresh_turns: int, +) -> None: + """Replace tool messages older than ``fresh_turns`` with a placeholder. + + ``messages`` only ever grows within one episode (see module docstring + point 1); this is what keeps that growth bounded instead of resending + every past tool result on every later turn. + """ + for entry in tool_message_log: + if entry["collapsed"]: + continue + if current_turn - entry["turn_index"] < fresh_turns: + continue + messages[entry["message_index"]]["content"] = ( + f"[collapsed: {entry['tool_name']} result from turn " + f"{entry['turn_index']} was {entry['original_chars']} chars — " + "call the tool again if you need it back in view]" + ) + entry["collapsed"] = True + + +class OpenAIHarness: + """``Harness`` implementation over an OpenAI-compatible function-calling loop.""" + + async def run_episode( + self, + *, + db_factory: DbFactory, + user_id: str, + namespace: str, + query: str, + budget: EpisodeBudget, + ) -> EpisodeResult: + tool_budget = ToolBudget() + client, model = _resolve_client_and_model() + openai_tools, tool_name_map = _build_openai_tools() + + system_prompt = load_corpus_schema_text() + LOOP_CONTRACT_SUFFIX + messages: list[dict[str, Any]] = [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": query}, + ] + + steps: list[AgentStep] = [] + stop_reason = "finished" + result_refs: list[dict[str, Any]] = [] + result_notes = "" + # Refs from every corpus.read/corpus.assets call this episode, in call + # order — the fallback source when finish's own refs end up empty (see + # module docstring point 2). + trajectory_refs: list[dict[str, Any]] = [] + # One entry per appended tool-role message: {message_index, turn_index, + # tool_name, original_chars, collapsed} — see _collapse_stale_tool_messages. + tool_message_log: list[dict[str, Any]] = [] + turn_index = 0 + + while True: + turn_index += 1 + _collapse_stale_tool_messages( + messages, + tool_message_log, + current_turn=turn_index, + fresh_turns=_TOOL_MESSAGE_FRESH_TURNS, + ) + + forced_reason = budget.exhausted() + tool_choice: Any = "auto" + if forced_reason is not None: + tool_choice = {"type": "function", "function": {"name": FINISH_TOOL_NAME}} + + turn_started = time.perf_counter() + response, usage = await asyncio.to_thread( + client.chat_completion_raw_with_usage, + messages=messages, + model=model, + temperature=0.0, + max_tokens=AGENT_EXPLORE_MAX_COMPLETION_TOKENS, + tools=openai_tools, + tool_choice=tool_choice, + ) + budget.record_usage(usage) + budget.record_step() + turn_elapsed_ms = int((time.perf_counter() - turn_started) * 1000) + turn_tokens = int((usage or {}).get("total_tokens", 0) or 0) + + message = response.choices[0].message + tool_calls = list(message.tool_calls or []) + + if not tool_calls: + stop_reason = f"budget_{forced_reason}" if forced_reason else "no_tool_call" + result_notes = str(message.content or "") + steps.append( + AgentStep( + step_index=len(steps), + tool_name="", + tool_args={}, + observation_text=result_notes, + error=None, + elapsed_ms=turn_elapsed_ms, + tokens_used_delta=turn_tokens, + tokens_used_total=budget.tokens_used, + ) + ) + break + + finish_call = next( + (tc for tc in tool_calls if tc.function.name == FINISH_TOOL_NAME), None + ) + if finish_call is not None: + args = _safe_json_loads(finish_call.function.arguments) + result_refs = normalize_finish_refs(args.get("refs")) + result_notes = str(args.get("notes") or "") + stop_reason = f"budget_{forced_reason}" if forced_reason else "finished" + steps.append( + AgentStep( + step_index=len(steps), + tool_name=FINISH_TOOL_NAME, + tool_args=args, + observation_text=f"refs={len(result_refs)} notes={result_notes!r}", + error=None, + elapsed_ms=turn_elapsed_ms, + tokens_used_delta=turn_tokens, + tokens_used_total=budget.tokens_used, + ) + ) + break + + if forced_reason is not None: + # Forced tool_choice=finish but the provider returned a + # different tool anyway (not observed in verification, but a + # budget cutoff must never loop past). Stop here regardless. + stop_reason = f"budget_{forced_reason}" + result_notes = str(message.content or "") or ( + "budget exhausted; provider did not return finish" + ) + steps.append( + AgentStep( + step_index=len(steps), + tool_name="", + tool_args={}, + observation_text=result_notes, + error="forced_finish_not_honored", + elapsed_ms=turn_elapsed_ms, + tokens_used_delta=turn_tokens, + tokens_used_total=budget.tokens_used, + ) + ) + break + + messages.append( + { + "role": "assistant", + "content": message.content or "", + "tool_calls": [ + { + "id": tc.id, + "type": "function", + "function": { + "name": tc.function.name, + "arguments": tc.function.arguments, + }, + } + for tc in tool_calls + ], + } + ) + first_tool_tokens_recorded = False + for tc in tool_calls: + tool_started = time.perf_counter() + args = _safe_json_loads(tc.function.arguments) + requested_name = str(tc.function.name or "") + canonical_name = tool_name_map.get(requested_name, requested_name) + tool_result = await dispatch_tool_call( + canonical_name, + args, + db_factory=db_factory, + user_id=user_id, + namespace=namespace, + budget=tool_budget, + ) + tool_elapsed_ms = int((time.perf_counter() - tool_started) * 1000) + content = tool_message_content(tool_result, max_chars=tool_budget.max_chars) + messages.append( + {"role": "tool", "tool_call_id": tc.id, "content": content} + ) + tool_message_log.append( + { + "message_index": len(messages) - 1, + "turn_index": turn_index, + "tool_name": canonical_name, + "original_chars": len(content), + "collapsed": False, + } + ) + if canonical_name in EVIDENCE_TOOL_NAMES and not tool_result.error: + trajectory_refs.extend(tool_result.refs) + # Turn-level token usage is attributed to the first tool step in + # this turn (the completion that decided all calls in it); the + # rest are 0 to avoid double-counting the same LLM usage. + steps.append( + AgentStep( + step_index=len(steps), + tool_name=canonical_name, + tool_args=args, + observation_text=content, + error=tool_result.error, + elapsed_ms=( + tool_elapsed_ms + if first_tool_tokens_recorded + else turn_elapsed_ms + tool_elapsed_ms + ), + tokens_used_delta=0 if first_tool_tokens_recorded else turn_tokens, + tokens_used_total=budget.tokens_used, + ) + ) + first_tool_tokens_recorded = True + + if not result_refs: + fallback_refs = dedup_refs(trajectory_refs) + if fallback_refs: + result_refs = fallback_refs + result_notes = (result_notes + " " if result_notes else "") + ( + "[refs auto-filled from corpus.read/corpus.assets trajectory; " + "finish did not cite any]" + ) + + return EpisodeResult( + refs=result_refs, + notes=result_notes, + steps=steps, + stop_reason=stop_reason, + tokens_used=budget.tokens_used, + model_name=model, + ) diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/resolve.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/resolve.py new file mode 100644 index 00000000..449a636e --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/resolve.py @@ -0,0 +1,41 @@ +"""``AGENT_EXPLORE_HARNESS`` env switch — same pattern as ``execution/routes.py``'s +``_resolve_agentic_router()`` (``RETRIEVAL_AGENTIC_ROUTER``): unrecognized or +unset values fall back to the default rather than raising, so a typo'd env +var degrades to known-good behavior instead of breaking the route. + +Each branch below imports its harness implementation lazily so that +selecting ``openai`` never imports ``cursor_sdk``-dependent code (and +vice versa) — see ``cursor_harness.py``'s guarded import. +""" + +from __future__ import annotations + +import os + +from shared.services.retrieval.agent_explore.harness.base import Harness + +_HARNESS_ENV = "AGENT_EXPLORE_HARNESS" +_HARNESSES = {"openai", "cursor_sdk"} +_DEFAULT_HARNESS = "openai" + + +def resolve_harness_name() -> str: + """``openai`` (default, current production behavior) or ``cursor_sdk``.""" + value = os.environ.get(_HARNESS_ENV, "").strip().lower() + return value if value in _HARNESSES else _DEFAULT_HARNESS + + +def resolve_harness(name: str | None = None) -> Harness: + """Build the ``Harness`` implementation for ``name`` (default: env-resolved).""" + resolved = (name or resolve_harness_name()).strip().lower() + if resolved == "cursor_sdk": + from shared.services.retrieval.agent_explore.harness.cursor_harness import ( + CursorHarness, + ) + + return CursorHarness() + from shared.services.retrieval.agent_explore.harness.openai_harness import ( + OpenAIHarness, + ) + + return OpenAIHarness() diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/shared.py b/packages/shared-python/shared/services/retrieval/agent_explore/shared.py new file mode 100644 index 00000000..dbb61cf0 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_explore/shared.py @@ -0,0 +1,106 @@ +"""Provider-agnostic helpers shared by every ``agent_explore`` harness. + +Extracted from ``episode.py`` (originally OpenAI-harness-specific) once a +second harness (``harness/cursor_harness.py``) needed the exact same logic +and, as a debug-script PoC, had started duplicating and drifting from it +instead of sharing it — see the Phase 3.5 section of +``.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md``. + +Deliberately excludes anything that assumes an editable ``messages: +list[dict]`` conversation history (that's OpenAI-harness-specific — see +``harness/openai_harness.py``'s ``_collapse_stale_tool_messages``, which is +NOT here because the Cursor SDK manages its own context with no equivalent +hook exposed to the host process). +""" + +from __future__ import annotations + +from typing import Any + +from shared.services.retrieval.agent_tools import ToolResult + +# Tools whose ToolResult.refs point at evidence the agent has actually looked +# at (full body content), as opposed to candidate/listing refs from +# list_documents/outline/node_filter/recall/grep — those describe *where +# things are*, not *what was read*, and would inject unread noise into the +# trajectory-refs fallback below if included. +EVIDENCE_TOOL_NAMES = frozenset({"corpus.read", "corpus.assets"}) + + +def wire_safe_tool_name(name: str) -> str: + """Replace ``.`` with ``_`` in a tool name for function-calling wire formats. + + Every ``agent_tools`` name is dotted (``corpus.read``); DeepSeek's + (OpenAI-compatible) function-calling API rejects ``.`` in + ``tools[].function.name`` (must match ``^[a-zA-Z0-9_-]+$``, verified + live), and the Cursor SDK PoC needed the identical replacement for its + own ``custom_tools`` wire names — this is a function-calling wire-format + restriction shared by both providers, not an OpenAI-specific quirk. The + dotted name stays canonical in ``REGISTRY``/MCP; this underscore form + exists only for providers whose wire format rejects dots. + """ + return name.replace(".", "_") + + +def build_wire_tool_name_map(names: list[str]) -> dict[str, str]: + """``{wire_safe_name: canonical_name}`` for every name in ``names``. + + Names that are already wire-safe (e.g. ``finish``, which has no dot) map + to themselves. Used by a harness to translate a provider's tool-call + name back to the canonical ``REGISTRY`` name before dispatch. + """ + return {wire_safe_tool_name(name): name for name in names} + + +def tool_message_content(result: ToolResult, *, max_chars: int) -> str: + """Cap a tool's rendered text before it enters LLM context. + + Uses the caller's ``ToolBudget.max_chars`` (``EVIDENCE_TEXT_CHAR_BUDGET``, + aligned with map-nav evidence packing — see ``agent_tools/registry.py``) + so tools like ``read`` can return unbounded body text while the harness + still bounds what the model sees per turn. This cap applies uniformly to + every tool's rendered text (not just ``read``'s body content) — a tool + that returns a "complete, non-truncated" *matched set* by contract + (``outline``, ``node_filter``) still has its *rendered text* capped here + the same as any other tool; that promise is about payload/refs + cardinality, not about how much of it is shown to the LLM per turn. + """ + if result.error: + return f"error: {result.error}" + text = result.text or "(empty result)" + if len(text) <= max_chars: + return text + omitted = len(text) - max_chars + return ( + text[:max_chars] + + f"\n...[truncated, {omitted} more chars — narrow the scope " + "(e.g. depth/path_prefix for outline, a tighter predicate for " + "node_filter, or a more specific ref for read) and call again if " + "you need the rest]" + ) + + +def normalize_finish_refs(raw: Any) -> list[dict[str, Any]]: + """Keep only dict items with a non-empty ``document_id`` from a raw ``finish.refs``.""" + if not isinstance(raw, list): + return [] + normalized: list[dict[str, Any]] = [] + for item in raw: + if isinstance(item, dict) and str(item.get("document_id") or "").strip(): + normalized.append(item) + return normalized + + +def dedup_refs(refs: list[dict[str, Any]]) -> list[dict[str, Any]]: + """Dedup by ``(document_id, chunk_id)``, keeping first-seen order.""" + seen: set[tuple[str, str]] = set() + deduped: list[dict[str, Any]] = [] + for ref in refs: + document_id = str(ref.get("document_id") or "").strip() + chunk_id = str(ref.get("chunk_id") or "").strip() + key = (document_id, chunk_id) + if not document_id or not chunk_id or key in seen: + continue + seen.add(key) + deduped.append(ref) + return deduped diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/registry.py b/packages/shared-python/shared/services/retrieval/agent_tools/registry.py index 609de82e..61861fd0 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/registry.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/registry.py @@ -36,7 +36,7 @@ class ToolBudget: matched-set cardinality — see ``CORPUS_SCHEMA.md`` §6. ``max_chars`` caps the rendered ``ToolResult.text`` before it enters LLM - context. Applied in ``agent_explore.episode._tool_message_content`` (not + context. Applied in ``agent_explore.shared.tool_message_content`` (not inside individual tools) so ``read`` can return full body text from the tool while the harness still bounds what the model sees per turn. Aligned with map-nav final evidence packing via ``EVIDENCE_TEXT_CHAR_BUDGET`` diff --git a/packages/shared-python/shared/services/retrieval/execution/routes.py b/packages/shared-python/shared/services/retrieval/execution/routes.py index 23b17859..66811ef8 100644 --- a/packages/shared-python/shared/services/retrieval/execution/routes.py +++ b/packages/shared-python/shared/services/retrieval/execution/routes.py @@ -216,22 +216,28 @@ async def _run_agent_explore_route( Selected when ``RETRIEVAL_AGENTIC_ROUTER=agent_explore``; ``mapnav`` remains the default route until this one passes its Phase 4 evaluation gate. See ``shared/services/retrieval/agent_explore/``. + + Which provider actually runs the tool-calling loop (OpenAI-compatible + default, or Cursor SDK) is the separate ``AGENT_EXPLORE_HARNESS`` switch + (Phase 3.5) resolved by ``resolve_harness()`` below — independent of + this route selection. """ from shared.services.retrieval.agent_explore.bridge import build_decision_trace - from shared.services.retrieval.agent_explore.episode import ( - run_agent_explore_episode, - ) + from shared.services.retrieval.agent_explore.budget import EpisodeBudget + from shared.services.retrieval.agent_explore.harness import resolve_harness from shared.services.retrieval.agent_explore.ref_resolution import ( resolve_finish_refs, ) from shared.services.retrieval.trace import TraceRecorder + harness = resolve_harness() episode_started = time.perf_counter() - episode = await run_agent_explore_episode( - db=context.db, + episode = await harness.run_episode( + db_factory=open_fresh_database_context, user_id=context.user_id, namespace=context.namespace, query=context.query, + budget=EpisodeBudget(), ) logger.info( "retrieval agent_explore stage=episode seconds={:.3f} refs={} " diff --git a/packages/shared-python/shared/tests/test_agent_explore_harness.py b/packages/shared-python/shared/tests/test_agent_explore_harness.py new file mode 100644 index 00000000..f005de2d --- /dev/null +++ b/packages/shared-python/shared/tests/test_agent_explore_harness.py @@ -0,0 +1,195 @@ +"""Unit tests for the Phase 3.5 ``agent_explore`` harness layer. + +Covers only the pure functions and the ``AGENT_EXPLORE_HARNESS`` switch +resolution — none of these need a real DB or LLM. Does not cover +``dispatch.dispatch_tool_call`` (needs a DB session) or a full +``Harness.run_episode`` loop (needs an LLM/Cursor SDK backend) — those stay +integration-level, exercised via the debug scripts and +``eval-cursor-harness``, not here. +""" + +from __future__ import annotations + +import os + +os.environ.setdefault("DATABASE_URL", "postgresql+asyncpg://test:test@localhost/test") +os.environ.setdefault("TMP_PATH", "/tmp/knowhere-test") +os.environ.setdefault("S3_BUCKET_NAME", "test-uploads") +os.environ.setdefault("S3_ACCESS_KEY_ID", "test") +os.environ.setdefault("S3_SECRET_ACCESS_KEY", "test") +os.environ.setdefault("S3_TEMP_PATH", "/tmp") + +import pytest + +from shared.services.retrieval.agent_explore.harness.base import Harness +from shared.services.retrieval.agent_explore.harness.resolve import ( + _HARNESS_ENV, + resolve_harness, + resolve_harness_name, +) +from shared.services.retrieval.agent_explore.shared import ( + EVIDENCE_TOOL_NAMES, + build_wire_tool_name_map, + dedup_refs, + normalize_finish_refs, + tool_message_content, + wire_safe_tool_name, +) +from shared.services.retrieval.agent_tools import ToolResult + + +# -------------------------------------------------------------------------- +# shared.py: wire-safe tool name mapping +# -------------------------------------------------------------------------- + + +def test_wire_safe_tool_name_replaces_dots() -> None: + assert wire_safe_tool_name("corpus.read") == "corpus_read" + assert wire_safe_tool_name("corpus.node_filter") == "corpus_node_filter" + # Already wire-safe names are untouched. + assert wire_safe_tool_name("finish") == "finish" + + +def test_build_wire_tool_name_map_round_trips_to_canonical() -> None: + mapping = build_wire_tool_name_map(["corpus.read", "corpus.recall", "finish"]) + assert mapping == { + "corpus_read": "corpus.read", + "corpus_recall": "corpus.recall", + "finish": "finish", + } + + +# -------------------------------------------------------------------------- +# shared.py: tool_message_content (max_chars capping) +# -------------------------------------------------------------------------- + + +def test_tool_message_content_passes_through_short_text() -> None: + result = ToolResult(text="short body") + assert tool_message_content(result, max_chars=100) == "short body" + + +def test_tool_message_content_caps_long_text_with_note() -> None: + result = ToolResult(text="x" * 200) + content = tool_message_content(result, max_chars=100) + assert content.startswith("x" * 100) + assert "truncated, 100 more chars" in content + assert len(content) > 100 # capped body + truncation note, not silently dropped + + +def test_tool_message_content_surfaces_error_instead_of_text() -> None: + result = ToolResult(text="ignored", error="bad args: missing document_id") + assert tool_message_content(result, max_chars=100) == "error: bad args: missing document_id" + + +def test_tool_message_content_empty_text_placeholder() -> None: + result = ToolResult(text="") + assert tool_message_content(result, max_chars=100) == "(empty result)" + + +# -------------------------------------------------------------------------- +# shared.py: normalize_finish_refs / dedup_refs +# -------------------------------------------------------------------------- + + +def test_normalize_finish_refs_drops_non_dict_and_empty_document_id() -> None: + raw = [ + {"document_id": "doc_a", "chunk_id": "c1"}, + {"document_id": "", "chunk_id": "c2"}, + {"chunk_id": "c3"}, + "not a dict", + None, + {"document_id": "doc_b"}, + ] + normalized = normalize_finish_refs(raw) + assert normalized == [ + {"document_id": "doc_a", "chunk_id": "c1"}, + {"document_id": "doc_b"}, + ] + + +def test_normalize_finish_refs_non_list_input_is_empty() -> None: + assert normalize_finish_refs(None) == [] + assert normalize_finish_refs("refs") == [] + assert normalize_finish_refs({"document_id": "doc_a"}) == [] + + +def test_dedup_refs_keeps_first_seen_and_drops_missing_ids() -> None: + refs = [ + {"document_id": "doc_a", "chunk_id": "c1", "section_path": "first"}, + {"document_id": "doc_a", "chunk_id": "c1", "section_path": "duplicate"}, + {"document_id": "doc_a", "chunk_id": "c2"}, + {"document_id": "doc_a"}, # missing chunk_id -> dropped + {"chunk_id": "c3"}, # missing document_id -> dropped + {"document_id": "doc_b", "chunk_id": "c1"}, + ] + deduped = dedup_refs(refs) + assert deduped == [ + {"document_id": "doc_a", "chunk_id": "c1", "section_path": "first"}, + {"document_id": "doc_a", "chunk_id": "c2"}, + {"document_id": "doc_b", "chunk_id": "c1"}, + ] + + +def test_evidence_tool_names_is_read_and_assets_only() -> None: + assert EVIDENCE_TOOL_NAMES == frozenset({"corpus.read", "corpus.assets"}) + + +# -------------------------------------------------------------------------- +# harness/resolve.py: AGENT_EXPLORE_HARNESS switch +# -------------------------------------------------------------------------- + + +@pytest.fixture(autouse=True) +def _clean_harness_env(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.delenv(_HARNESS_ENV, raising=False) + + +def test_resolve_harness_name_defaults_to_openai() -> None: + assert resolve_harness_name() == "openai" + + +def test_resolve_harness_name_reads_env(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setenv(_HARNESS_ENV, "cursor_sdk") + assert resolve_harness_name() == "cursor_sdk" + + +def test_resolve_harness_name_unknown_value_falls_back_to_default( + monkeypatch: pytest.MonkeyPatch, +) -> None: + monkeypatch.setenv(_HARNESS_ENV, "not_a_real_harness") + assert resolve_harness_name() == "openai" + + +def test_resolve_harness_name_is_case_insensitive(monkeypatch: pytest.MonkeyPatch) -> None: + monkeypatch.setenv(_HARNESS_ENV, "CURSOR_SDK") + assert resolve_harness_name() == "cursor_sdk" + + +def test_resolve_harness_default_builds_openai_harness() -> None: + from shared.services.retrieval.agent_explore.harness.openai_harness import OpenAIHarness + + harness = resolve_harness() + assert isinstance(harness, OpenAIHarness) + assert isinstance(harness, Harness) + + +def test_resolve_harness_cursor_sdk_builds_cursor_harness_without_sdk_installed() -> None: + """Selecting cursor_sdk must not require the optional cursor-sdk package + to be importable — only actually running an episode does (see + cursor_harness.py's guarded _require_cursor_sdk, exercised at + run_episode() call time, not at harness construction time). + """ + from shared.services.retrieval.agent_explore.harness.cursor_harness import CursorHarness + + harness = resolve_harness("cursor_sdk") + assert isinstance(harness, CursorHarness) + assert isinstance(harness, Harness) + + +def test_resolve_harness_explicit_name_overrides_env(monkeypatch: pytest.MonkeyPatch) -> None: + from shared.services.retrieval.agent_explore.harness.openai_harness import OpenAIHarness + + monkeypatch.setenv(_HARNESS_ENV, "cursor_sdk") + harness = resolve_harness("openai") + assert isinstance(harness, OpenAIHarness) diff --git a/uv.lock b/uv.lock index 77a0eee5..4c1be47b 100644 --- a/uv.lock +++ b/uv.lock @@ -805,6 +805,22 @@ wheels = [ { url = "https://files.pythonhosted.org/packages/20/2a/1b016902351a523aa2bd446b50a5bc1175d7a7d1cf90fe2ef904f9b84ebc/cryptography-46.0.7-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:258514877e15963bd43b558917bc9f54cf7cf866c38aa576ebf47a77ddbc43a4", size = 3412829, upload-time = "2026-04-08T01:57:48.874Z" }, ] +[[package]] +name = "cursor-sdk" +version = "1.0.31" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "httpx" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/82/ca/60a7ea6a8b08a430a499797261487cf9114fbbfb652e10379a1f98dde463/cursor_sdk-1.0.31.tar.gz", hash = "sha256:fcdd279852d0b3eea4e4c4562dcd1c7d18360f507d2830bd2de79b6d855276a5", size = 1177, upload-time = "2026-09-03T21:04:04.352Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/18/1ea7bd9823dde860a44c68a0e920d07a415e5f73c4c3693cc8f22a081220/cursor_sdk-1.0.31-py3-none-macosx_11_0_arm64.whl", hash = "sha256:0b7b1e8fb677fe400c9d63518ff08465a7527cd23f20a3d857bf9454ab99c411", size = 49516626, upload-time = "2026-09-03T21:03:49.927Z" }, + { url = "https://files.pythonhosted.org/packages/ca/21/df0f17f3bd3d956897756e5bf4dbed355ad9261d0b7efa3d1af703912fee/cursor_sdk-1.0.31-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:22cb11230491cd989eb7015cb3778f09ba1e6a974661ddace5bee1e68f85ee8b", size = 51027071, upload-time = "2026-09-03T21:03:52.837Z" }, + { url = "https://files.pythonhosted.org/packages/28/96/de1b8b0275c792d9a472b8e61fe12e0d9bcd3f49551658361f43d8d381ac/cursor_sdk-1.0.31-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ae97e49570887953922eb6b3b84cb02c2d13e795fe4b3968f25e23ab569cf21f", size = 58623238, upload-time = "2026-09-03T21:03:55.741Z" }, + { url = "https://files.pythonhosted.org/packages/e9/f1/25188d01c7bd0b42edee594225353176f90747047c1508bc315c0d2a3706/cursor_sdk-1.0.31-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e9b87cd80fe428b1a2ee88b4a08aac6297179a33f809d650f0383901fb60a766", size = 59314084, upload-time = "2026-09-03T21:03:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/de/60/e36b7d68ae702781fac63fef564fc9d643495b114fb959e442d449e537cf/cursor_sdk-1.0.31-py3-none-win_amd64.whl", hash = "sha256:12d87c639ac1bdb50958028e81f295f856e8e9a4d784977ea0e07d196716410e", size = 45610437, upload-time = "2026-09-03T21:04:01.878Z" }, +] + [[package]] name = "deprecated" version = "1.3.1" @@ -1588,6 +1604,11 @@ dependencies = [ { name = "tqdm" }, ] +[package.optional-dependencies] +cursor-harness = [ + { name = "cursor-sdk" }, +] + [package.dev-dependencies] dev = [ { name = "fakeredis", extra = ["lua"] }, @@ -1601,6 +1622,7 @@ dev = [ requires-dist = [ { name = "beautifulsoup4", specifier = "==4.13.4" }, { name = "cryptography", specifier = "==46.0.7" }, + { name = "cursor-sdk", marker = "extra == 'cursor-harness'", specifier = ">=1.0.31" }, { name = "gevent", specifier = ">=24.11.1" }, { name = "httpcore", specifier = ">=1.0.6" }, { name = "jieba", specifier = "==0.42.1" }, @@ -1624,6 +1646,7 @@ requires-dist = [ { name = "tabula-py", specifier = ">=2.10.0" }, { name = "tqdm", specifier = "==4.67.1" }, ] +provides-extras = ["cursor-harness"] [package.metadata.requires-dev] dev = [ From 94fbf038e6b59a44077116bce2dddad48c43c8ae Mon Sep 17 00:00:00 2001 From: chengke <404835780@qq.com> Date: Tue, 8 Sep 2026 19:56:58 +0800 Subject: [PATCH 10/15] feat(retrieval): enhance agent exploration with budget tracking and path resolution Updated the agent exploration logic to include a budget status line in tool observations, allowing the model to self-regulate based on remaining budget. Improved section path resolution by integrating a new method for handling ambiguous paths and ensuring accurate references during retrieval. Enhanced documentation to clarify the behavior of the `read` tool regarding section paths and added notes for better guidance on recall tool usage. --- .../retrieval/agent_explore/config.py | 9 ++ .../agent_explore/harness/cursor_harness.py | 10 ++- .../agent_explore/harness/openai_harness.py | 9 ++ .../retrieval/agent_explore/ref_resolution.py | 20 ++++- .../retrieval/agent_explore/shared.py | 20 +++++ .../retrieval/agent_tools/CORPUS_SCHEMA.md | 2 +- .../agent_tools/section_path_lookup.py | 87 +++++++++++++++++++ .../retrieval/agent_tools/tools/read.py | 39 ++++++--- .../retrieval/agent_tools/tools/recall.py | 12 +++ .../shared/tests/test_section_path_lookup.py | 39 +++++++++ 10 files changed, 227 insertions(+), 20 deletions(-) create mode 100644 packages/shared-python/shared/services/retrieval/agent_tools/section_path_lookup.py create mode 100644 packages/shared-python/shared/tests/test_section_path_lookup.py diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/config.py b/packages/shared-python/shared/services/retrieval/agent_explore/config.py index 52d5cd87..961003cf 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/config.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/config.py @@ -111,4 +111,13 @@ read that supports your answer into `refs` before calling `{FINISH_TOOL_NAME}`. Calling `{FINISH_TOOL_NAME}` with no `refs` after having already read relevant content discards that evidence. + +Before calling `{FINISH_TOOL_NAME}`, if you have not called `corpus.read` +(or `corpus.assets`) even once this exploration, you have not actually +verified anything yet — a search tool returning candidates is not the same +as having read them. In that case, either read your best candidate section +first, or — only if you have positively confirmed there is nothing to read +(e.g. a structural check came back with zero matching sections) — say so +explicitly in `notes`. Repeatedly rephrasing the same search instead of +reading a candidate you already found is not a substitute for reading it. """ diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py index f4436518..8196f05b 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py @@ -81,6 +81,7 @@ from shared.services.retrieval.agent_explore.dispatch import DbFactory, dispatch_tool_call from shared.services.retrieval.agent_explore.shared import ( EVIDENCE_TOOL_NAMES, + budget_status_line, dedup_refs, normalize_finish_refs, tool_message_content, @@ -192,12 +193,17 @@ def _dispatch_sync(tool_name: str, args: dict[str, Any]) -> str: tool_result = ToolResult(text="", error=f"{type(exc).__name__}: {exc}") elapsed_ms = int((time.perf_counter() - tool_started) * 1000) content = tool_message_content(tool_result, max_chars=tool_budget.max_chars) + # Appended per call, unlike openai_harness.py's once-per-turn + # placement — this harness has no batched-turn concept exposed to + # the host process (see module docstring): each corpus.* dispatch + # is the only per-step hook available to surface budget state. + content_with_budget = content + "\n" + budget_status_line(budget) steps.append( AgentStep( step_index=len(steps), tool_name=tool_name, tool_args=args, - observation_text=content, + observation_text=content_with_budget, error=tool_result.error, elapsed_ms=elapsed_ms, tokens_used_delta=0, @@ -206,7 +212,7 @@ def _dispatch_sync(tool_name: str, args: dict[str, Any]) -> str: ) if tool_name in EVIDENCE_TOOL_NAMES and not tool_result.error: trajectory_refs.extend(tool_result.refs) - return content + return content_with_budget custom_tools: dict[str, Any] = {} for spec in REGISTRY.all(): diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py index dd8df212..0f86c2fd 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py @@ -68,6 +68,7 @@ from shared.services.retrieval.agent_explore.dispatch import DbFactory, dispatch_tool_call from shared.services.retrieval.agent_explore.shared import ( EVIDENCE_TOOL_NAMES, + budget_status_line, build_wire_tool_name_map, dedup_refs, normalize_finish_refs, @@ -364,6 +365,14 @@ async def run_episode( ) first_tool_tokens_recorded = True + # Appended once per turn, to the last tool message only (not + # every AgentStep's recorded observation_text above) — the model + # only needs to see current remaining budget once before its next + # completion call, not once per parallel tool call in this turn. + messages[-1]["content"] = ( + str(messages[-1]["content"]) + "\n" + budget_status_line(budget) + ) + if not result_refs: fallback_refs = dedup_refs(trajectory_refs) if fallback_refs: diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/ref_resolution.py b/packages/shared-python/shared/services/retrieval/agent_explore/ref_resolution.py index 36e1e982..5edeeac4 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/ref_resolution.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/ref_resolution.py @@ -12,8 +12,9 @@ LLM does not see). This module closes that gap at the harness boundary instead of changing what the agent is taught to cite: for any ref missing ``chunk_id``, resolve that section's own body chunk — the same "one section, -one body chunk" lookup ``corpus.read``'s ``section_path`` branch already -performs (``agent_tools/tools/read.py``), not a new resolution rule. +one body chunk" lookup ``corpus.read``'s ``section_path`` branch performs +(``agent_tools/section_path_lookup.py``), including the same suffix fallback +when the agent cites a path without ancestor prefixes. """ from __future__ import annotations @@ -24,7 +25,9 @@ from sqlalchemy.ext.asyncio import AsyncSession from shared.models.database.document import Document, DocumentChunk, DocumentSection -from shared.services.retrieval.search.lexical_text import normalize_section_path +from shared.services.retrieval.agent_tools.section_path_lookup import ( + resolve_section_path_anchor, +) _BODY_CHUNK_TYPES = ("text", "page") @@ -73,6 +76,15 @@ async def resolve_finish_refs( if not (document_id and section_path and job_result_id): continue + resolved_path, path_error = await resolve_section_path_anchor( + db, + document_id=document_id, + job_result_id=job_result_id, + section_path=section_path, + ) + if path_error or not resolved_path: + continue + row = ( await db.execute( select(DocumentChunk.chunk_id) @@ -83,7 +95,7 @@ async def resolve_finish_refs( ) .where(DocumentChunk.document_id == document_id) .where(DocumentChunk.job_result_id == job_result_id) - .where(DocumentSection.section_path == normalize_section_path(section_path)) + .where(DocumentSection.section_path == resolved_path) .where(DocumentChunk.chunk_type.in_(_BODY_CHUNK_TYPES)) ) ).first() diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/shared.py b/packages/shared-python/shared/services/retrieval/agent_explore/shared.py index dbb61cf0..6b37821f 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/shared.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/shared.py @@ -17,6 +17,7 @@ from typing import Any +from shared.services.retrieval.agent_explore.budget import EpisodeBudget from shared.services.retrieval.agent_tools import ToolResult # Tools whose ToolResult.refs point at evidence the agent has actually looked @@ -91,6 +92,25 @@ def normalize_finish_refs(raw: Any) -> list[dict[str, Any]]: return normalized +def budget_status_line(budget: EpisodeBudget) -> str: + """One-line remaining-budget summary appended to a tool observation. + + Neither harness previously surfaced ``EpisodeBudget``'s own counters + (``steps_used``/``max_steps``, ``tokens_used``/``token_limit``, + elapsed/wall_clock) to the model at all — it had no way to tell "I'm on + step 3 of 12" from "I'm on step 11 of 12", so it could not self-regulate + when to stop exploring and call ``finish``. This exposes the same + ``EpisodeBudget.snapshot()`` data already used for the hard cutoff, + reused as a soft signal the model can read every turn. + """ + snap = budget.snapshot() + return ( + f"[budget: steps {snap['steps_used']}/{snap['max_steps']}, " + f"tokens {snap['tokens_used']}/{snap['token_limit']}, " + f"elapsed {snap['elapsed_seconds']:.0f}s/{snap['wall_clock_seconds']:.0f}s]" + ) + + def dedup_refs(refs: list[dict[str, Any]]) -> list[dict[str, Any]]: """Dedup by ``(document_id, chunk_id)``, keeping first-seen order.""" seen: set[tuple[str, str]] = set() diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/CORPUS_SCHEMA.md b/packages/shared-python/shared/services/retrieval/agent_tools/CORPUS_SCHEMA.md index 904d0f5f..ec65d189 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/CORPUS_SCHEMA.md +++ b/packages/shared-python/shared/services/retrieval/agent_tools/CORPUS_SCHEMA.md @@ -136,7 +136,7 @@ for anything finer-grained than a document pair. | `node_filter` | The task is a traversal/exclusion predicate — FOR ALL / EXISTS / ANY / NOT — over section titles or summaries ("which docs mention X in a heading," "sections NOT about Y") | one or more documents | Deterministic substring/regex match against `section_path` and `summary` only, not body text. Returns the full matching set and count, never a truncated top-K. If the predicate must run against body text, use `grep` instead. | | `grep` | Exact string / regex / identifier / number lookup that must run against body text | scoped by document/section/chunk_type | Returns match count plus snippets, so ANY/ALL logic can also close over body text, not just titles. | | `recall` | A fuzzy question where you don't know where the answer lives | namespace or scoped | Ranked candidates from `path_content` (BM25) + `term` (substring) channels fused by RRF; `vector` is reserved — see §5. Returns path and snippet, not full content. | -| `read` | You already know which section(s)/chunk(s) to read | one or more sections/chunks | Returns full body content, resolves `SAME-AS` markers into the owner's text, expands `connect_to` assets, and converts `page_assets` into URLs. | +| `read` | You already know which section(s)/chunk(s) to read | one or more sections/chunks | Returns full body content, resolves `SAME-AS` markers into the owner's text, expands `connect_to` assets, and converts `page_assets` into URLs. If your `section_path` omits ancestor segments (e.g. missing a top-level volume like `附件目录 /`), `read` tries a unique suffix match within the document; if several sections match, it returns an ambiguity error listing the full paths — copy the full path from `outline`/`grep`/`refs` when that happens. | | `assets` | You need images/tables directly, or need to find which section(s) host a given asset | one or more documents | Forward (by type/query) and reverse (asset → hosting section) lookup — see §3. | | `neighbors` | You need related documents in the same namespace | one document | Document-level `related` edges only — see §4. | diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/section_path_lookup.py b/packages/shared-python/shared/services/retrieval/agent_tools/section_path_lookup.py new file mode 100644 index 00000000..3df35992 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/agent_tools/section_path_lookup.py @@ -0,0 +1,87 @@ +"""Shared section_path resolution for agent tools and harness bridge. + +``corpus.read`` and ``resolve_finish_refs`` both need to turn an agent-supplied +``section_path`` into one canonical DB path. Agents often cite a suffix (e.g. +``3 工程地质 / 3.2 覆盖层``) while the stored path includes ancestors +(``附件目录 / 3 工程地质 / 3.2 覆盖层``). Exact match alone fails silently +downstream; this module adds a segment-bound suffix fallback and surfaces +ambiguity instead of guessing. +""" + +from __future__ import annotations + +from sqlalchemy import or_, select +from sqlalchemy.ext.asyncio import AsyncSession + +from shared.models.database.document import DocumentSection +from shared.services.retrieval.search.lexical_text import normalize_section_path + + +def paths_matching_section_ref(normalized: str, candidate_paths: list[str]) -> list[str]: + """Return paths that equal ``normalized`` or end with `` / {normalized}``.""" + if not normalized: + return [] + suffix = f" / {normalized}" + matches = [ + path + for path in candidate_paths + if path == normalized or (normalized != "Root" and path.endswith(suffix)) + ] + return sorted(dict.fromkeys(matches)) + + +def format_ambiguous_section_path_error(normalized: str, matches: list[str]) -> str: + return ( + f"ambiguous section_path {normalized!r}: matches {len(matches)} sections — " + "use the full path from outline/grep/refs: " + + "; ".join(matches) + ) + + +def section_path_anchor_filter(resolved_path: str): + """SQL filter for one section (``mode=self`` anchor).""" + return DocumentSection.section_path == resolved_path + + +def section_path_subtree_filter(resolved_path: str): + """SQL filter for a section and all descendants (``mode=descendants``).""" + return or_( + DocumentSection.section_path == resolved_path, + DocumentSection.section_path.like(f"{resolved_path} / %"), + ) + + +async def resolve_section_path_anchor( + db: AsyncSession, + *, + document_id: str, + job_result_id: str, + section_path: str, +) -> tuple[str | None, str | None]: + """Resolve one canonical ``section_path`` or return ``(None, error)``.""" + normalized = normalize_section_path(section_path) + base = ( + select(DocumentSection.section_path) + .where(DocumentSection.document_id == document_id) + .where(DocumentSection.job_result_id == job_result_id) + ) + + exact_row = (await db.execute(base.where(DocumentSection.section_path == normalized))).first() + if exact_row is not None and exact_row[0]: + return str(exact_row[0]), None + + suffix_filter = or_( + DocumentSection.section_path == normalized, + DocumentSection.section_path.like(f"% / {normalized}"), + ) + suffix_rows = ( + await db.execute(base.where(suffix_filter).order_by(DocumentSection.sort_order)) + ).all() + matches = paths_matching_section_ref( + normalized, [str(row[0]) for row in suffix_rows if row and row[0]] + ) + if not matches: + return None, f"unknown section_path for {document_id}: {normalized}" + if len(matches) > 1: + return None, format_ambiguous_section_path_error(normalized, matches) + return matches[0], None diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py index dd1f09e3..f5f99117 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/read.py @@ -15,6 +15,11 @@ SAME-AS marker (a different leaf's page), it is not recursively resolved in this pass — a disclosed scope limit, not a silent gap (the raw marker stays visible in the embedded text). + +``section_path`` refs are resolved via ``agent_tools.section_path_lookup``: +exact match first, then a unique segment-bound suffix match when the agent +omits ancestor segments; ambiguous suffix matches return an error listing +candidate full paths instead of picking one silently. """ from __future__ import annotations @@ -22,7 +27,7 @@ import re from typing import Any -from sqlalchemy import or_, select +from sqlalchemy import select from shared.models.database.document import ( Document, @@ -45,10 +50,12 @@ _image_display_content, ) from shared.services.retrieval.hydration.row_utils import normalize_chunk_type -from shared.services.retrieval.search.lexical_text import ( - normalize_section_path, - section_path_from_chunk_path, +from shared.services.retrieval.agent_tools.section_path_lookup import ( + resolve_section_path_anchor, + section_path_anchor_filter, + section_path_subtree_filter, ) +from shared.services.retrieval.search.lexical_text import section_path_from_chunk_path _SAME_AS_MARKER_RE = re.compile(r"\[SAME-AS (.+?) p(\d+)\]") _BODY_CHUNK_TYPES = ("text", "page") @@ -256,12 +263,21 @@ async def read(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: errors.append(f"ref for {document_id} needs section_path or chunk_id") continue - normalized = normalize_section_path(section_path) - path_filter = DocumentSection.section_path == normalized - if mode == "descendants": - path_filter = or_( - path_filter, DocumentSection.section_path.like(f"{normalized} / %") - ) + resolved_path, path_error = await resolve_section_path_anchor( + ctx.db, + document_id=document_id, + job_result_id=job_result_id, + section_path=section_path, + ) + if path_error or not resolved_path: + errors.append(path_error or f"unknown section_path for {document_id}") + continue + + path_filter = ( + section_path_subtree_filter(resolved_path) + if mode == "descendants" + else section_path_anchor_filter(resolved_path) + ) section_rows = ( ( await ctx.db.execute( @@ -275,9 +291,6 @@ async def read(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: .scalars() .all() ) - if not section_rows: - errors.append(f"unknown section_path for {document_id}: {normalized}") - continue section_ids = [s.section_id for s in section_rows] chunk_rows = ( await ctx.db.execute( diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py index a4c7f61d..57523885 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py @@ -239,6 +239,18 @@ async def recall(ctx: ToolContext, args: dict[str, Any]) -> ToolResult: fused = merge_channels_rrf(channel_rows, weights, top_k) lines = [f"candidates={len(fused)}"] + if len(fused) < 2: + # No tool name named here on purpose — this fires on *every* weak + # recall regardless of what a better next step happens to be for + # this corpus/query, so it nudges the agent to change approach + # without prescribing which other tool to reach for (that's already + # covered generically in CORPUS_SCHEMA.md §6's tool-selection table). + lines.append( + "note: few or no candidates for this phrasing — rephrasing the " + "query and calling recall again rarely surfaces more; a " + "different exploration approach is more likely to help than " + "repeating recall with synonyms." + ) if reserved_requested: lines.append(f"note: channels {sorted(reserved_requested)} are reserved, not run") if requested_top_k > top_k: diff --git a/packages/shared-python/shared/tests/test_section_path_lookup.py b/packages/shared-python/shared/tests/test_section_path_lookup.py new file mode 100644 index 00000000..037d7e1f --- /dev/null +++ b/packages/shared-python/shared/tests/test_section_path_lookup.py @@ -0,0 +1,39 @@ +"""Pure tests for agent_tools section_path suffix resolution.""" + +from __future__ import annotations + +from shared.services.retrieval.agent_tools.section_path_lookup import ( + format_ambiguous_section_path_error, + paths_matching_section_ref, +) + + +def test_paths_matching_section_ref_exact() -> None: + paths = ["附件目录 / 1.1 概述", "综合说明 / 1.1 概述"] + assert paths_matching_section_ref("附件目录 / 1.1 概述", paths) == ["附件目录 / 1.1 概述"] + + +def test_paths_matching_section_ref_suffix() -> None: + paths = [ + "附件目录 / 3 工程地质 / 3.2 覆盖层", + "综合说明 / 3 工程地质 / 3.2 覆盖层", + ] + assert paths_matching_section_ref("3 工程地质 / 3.2 覆盖层", paths) == sorted(paths) + + +def test_paths_matching_section_ref_no_substring_false_positive() -> None: + paths = ["附件目录 / 3.2 覆盖层处理", "附件目录 / 13.2 覆盖层"] + assert paths_matching_section_ref("3.2 覆盖层", paths) == [] + + +def test_paths_matching_section_ref_top_level() -> None: + paths = ["附件目录", "附件目录 / 1.1 概述"] + assert paths_matching_section_ref("附件目录", paths) == ["附件目录"] + + +def test_format_ambiguous_section_path_error_lists_candidates() -> None: + matches = ["A / X", "B / X"] + msg = format_ambiguous_section_path_error("X", matches) + assert "ambiguous section_path 'X'" in msg + assert "A / X" in msg + assert "B / X" in msg From 2531c0fc81cc74753d69af110f091d83cad1c2c2 Mon Sep 17 00:00:00 2001 From: chengke <404835780@qq.com> Date: Tue, 8 Sep 2026 21:16:45 +0800 Subject: [PATCH 11/15] feat(retrieval): default to agent_explore and retire map-nav Archive map-nav out of the live path, keep shared scoring for classic BM25 and corpus.recall, drop the FTS fallback and unused chunk tsvector columns, and use cursor_sdk unless use_agentic is false. Co-authored-by: Cursor --- AGENTS.md | 35 +- apps/api/.env.example | 8 +- apps/api/alembic/env.py | 23 +- ...5a6b7c8d9_drop_chunk_search_tsv_columns.py | 55 +++ apps/api/app/api/v1/routes/retrieval.py | 4 +- apps/api/main.py | 12 + apps/api/pyproject.toml | 1 + .../scripts/backfill_map_unit_statistics.py | 2 +- ...est_retrieval_classic_map_unit_contract.py | 381 +++++++++--------- .../tests/contract/test_retrieval_contract.py | 298 +++++++------- apps/worker/.env.example | 8 +- apps/worker/pyproject.toml | 6 +- .../worker/scripts/run_agentic_router_eval.py | 126 +++--- deploy/ecs/task-definition-api.staging.json | 3 +- .../ecs/task-definition-worker.staging.json | 3 +- deprecated/mapnav/README.md | 26 ++ .../mapnav}/nav/__init__.py | 0 .../mapnav}/nav/_compat.py | 0 .../mapnav}/nav/nav_actions.py | 0 .../mapnav}/nav/nav_address.py | 0 .../mapnav}/nav/nav_agent.py | 0 .../mapnav}/nav/nav_assets.py | 0 .../mapnav}/nav/nav_compose.py | 0 .../mapnav}/nav/nav_control.py | 0 .../mapnav}/nav/nav_harvest.py | 0 deprecated/mapnav/nav/nav_hierarchy.py | 111 +++++ .../mapnav}/nav/nav_knowhere.py | 368 +---------------- .../mapnav}/nav/nav_llm.py | 0 .../mapnav}/nav/nav_map_scores.py | 271 +------------ .../mapnav}/nav/nav_navigate.py | 0 .../mapnav}/nav/nav_node_filter.py | 82 +--- .../mapnav}/nav/nav_orchestrate.py | 0 .../mapnav}/nav/nav_plan.py | 0 .../mapnav}/nav/nav_policy.py | 0 .../mapnav}/nav/nav_projection.py | 0 .../mapnav}/nav/nav_scope_filter.py | 3 +- .../mapnav}/nav/nav_token_budget.py | 0 .../mapnav}/nav/nav_types.py | 0 .../mapnav}/nav/nav_verify.py | 0 .../mapnav}/nav_bridge.py | 0 .../mapnav}/nav_config.py | 0 .../mapnav}/nav_llm_backend.py | 0 .../mapnav}/nav_snapshot.py | 6 +- ...etrieval_lazy_snapshot_quality_contract.py | 14 +- .../test_retrieval_lazy_tree_contract.py | 6 +- ...est_retrieval_map_score_parity_contract.py | 0 .../test_retrieval_map_unit_index_contract.py | 14 +- .../test_retrieval_mapnav_session_contract.py | 2 +- ...test_retrieval_relit_map_cache_contract.py | 0 ...st_retrieval_snapshot_batching_contract.py | 0 ...retrieval_snapshot_consistency_contract.py | 0 ...etrieval_snapshot_large_corpus_contract.py | 0 .../test_retrieval_snapshot_redis_contract.py | 0 .../tests/shared}/test_nav_bridge_config.py | 2 +- .../tests/shared}/test_nav_llm_backend.py | 0 .../tests/shared}/test_nav_node_filter.py | 8 +- .../shared}/test_nav_node_filter_wire.py | 6 +- .../shared}/test_nav_plan_node_filter.py | 0 .../tests/shared}/test_nav_plan_query_only.py | 0 .../tests/shared}/test_nav_projection_prod.py | 4 +- .../tests/shared}/test_nav_scope_filter.py | 9 +- .../mapnav/tests/shared}/test_nav_snapshot.py | 2 +- .../mapnav/tests/shared}/test_nav_stamp.py | 0 .../tests/shared}/test_nav_trace_map.py | 0 .../mapnav/trace_mapnav.py | 0 ...al-heart-vessel-trace-optimization-plan.md | 6 +- ...retrieval-serving-index-rollout-runbook.md | 25 +- docs/design/retrieval-streaming-sse.md | 32 +- .../shared/models/database/document.py | 28 -- .../retrieval/agent_explore/__init__.py | 18 +- .../retrieval/agent_explore/bridge.py | 9 +- .../retrieval/agent_explore/config.py | 23 +- .../agent_explore/harness/cursor_harness.py | 15 +- .../agent_explore/harness/openai_harness.py | 6 +- .../agent_explore/harness/resolve.py | 11 +- .../retrieval/agent_explore/shared.py | 2 +- .../retrieval/agent_tools/registry.py | 2 +- .../agent_tools/tools/node_filter.py | 4 +- .../retrieval/agent_tools/tools/recall.py | 6 +- .../services/retrieval/cache_service.py | 2 + .../retrieval/execution/query_request.py | 4 + .../execution/response_projection.py | 2 +- .../services/retrieval/execution/routes.py | 237 +---------- .../services/retrieval/map_unit_index.py | 12 +- .../services/retrieval/scoring/__init__.py | 1 + .../nav_hierarchy.py => scoring/hierarchy.py} | 129 +----- .../{nav => scoring}/knowhere_hybrid.py | 2 +- .../retrieval/scoring/knowhere_provider.py | 342 ++++++++++++++++ .../scoring/node_filter_predicates.py | 83 ++++ .../{nav => scoring}/persisted_score_load.py | 2 +- .../services/retrieval/scoring/score_units.py | 188 +++++++++ .../retrieval/search/map_unit_discovery.py | 129 +----- .../shared/services/retrieval/settings.py | 5 +- .../services/retrieval/trace/__init__.py | 12 - .../services/retrieval/trace/recorder.py | 5 +- .../tests/test_agent_explore_harness.py | 12 +- .../shared/tests/test_asset_inline.py | 4 +- .../tests/test_knowhere_hybrid_tokenize.py | 2 +- pyproject.toml | 3 +- pytest.ini | 2 + uv.lock | 2 + 101 files changed, 1441 insertions(+), 1825 deletions(-) create mode 100644 apps/api/alembic/versions/e4f5a6b7c8d9_drop_chunk_search_tsv_columns.py create mode 100644 deprecated/mapnav/README.md rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/__init__.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/_compat.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_actions.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_address.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_agent.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_assets.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_compose.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_control.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_harvest.py (100%) create mode 100644 deprecated/mapnav/nav/nav_hierarchy.py rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_knowhere.py (73%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_llm.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_map_scores.py (52%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_navigate.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_node_filter.py (70%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_orchestrate.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_plan.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_policy.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_projection.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_scope_filter.py (99%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_token_budget.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_types.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav/nav_verify.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav_bridge.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav_config.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav_llm_backend.py (100%) rename {packages/shared-python/shared/services/retrieval => deprecated/mapnav}/nav_snapshot.py (99%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_lazy_snapshot_quality_contract.py (97%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_lazy_tree_contract.py (93%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_map_score_parity_contract.py (100%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_map_unit_index_contract.py (99%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_mapnav_session_contract.py (98%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_relit_map_cache_contract.py (100%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_snapshot_batching_contract.py (100%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_snapshot_consistency_contract.py (100%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_snapshot_large_corpus_contract.py (100%) rename {apps/api/tests/contract => deprecated/mapnav/tests/api-contract}/test_retrieval_snapshot_redis_contract.py (100%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_bridge_config.py (98%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_llm_backend.py (100%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_node_filter.py (93%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_node_filter_wire.py (97%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_plan_node_filter.py (100%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_plan_query_only.py (100%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_projection_prod.py (95%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_scope_filter.py (95%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_snapshot.py (97%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_stamp.py (100%) rename {packages/shared-python/shared/tests => deprecated/mapnav/tests/shared}/test_nav_trace_map.py (100%) rename packages/shared-python/shared/services/retrieval/trace/mapnav.py => deprecated/mapnav/trace_mapnav.py (100%) create mode 100644 packages/shared-python/shared/services/retrieval/scoring/__init__.py rename packages/shared-python/shared/services/retrieval/{nav/nav_hierarchy.py => scoring/hierarchy.py} (75%) rename packages/shared-python/shared/services/retrieval/{nav => scoring}/knowhere_hybrid.py (99%) create mode 100644 packages/shared-python/shared/services/retrieval/scoring/knowhere_provider.py create mode 100644 packages/shared-python/shared/services/retrieval/scoring/node_filter_predicates.py rename packages/shared-python/shared/services/retrieval/{nav => scoring}/persisted_score_load.py (96%) create mode 100644 packages/shared-python/shared/services/retrieval/scoring/score_units.py diff --git a/AGENTS.md b/AGENTS.md index 503a16ad..fa13a28f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -103,13 +103,12 @@ flowchart TB subgraph RETRIEVE["⑤ Retrieval (shared)"] Query["POST /v1|/v2 retrieval/query"] --> Pipeline["run_retrieval_query"] Pipeline --> Classic["classic_topk / small_corpus (use_agentic=False)"] - Pipeline --> MapNav["mapnav checklist (default / use_agentic≠False)"] + Pipeline --> Explore["agent_explore + cursor_sdk (default / use_agentic≠False)"] Classic --> Channels["map_unit_discovery: path+content BM25 -> RRF"] Channels --> Rank["rank_retrieval_candidates"] - MapNav --> NavSnap["nav_snapshot + run_nav_episode"] - NavSnap --> Bridge["nav_bridge referenced_chunks"] + Explore --> Tools["corpus.* tools + harness.run_episode"] Rank --> Assemble["assemble_retrieval_results"] - Bridge --> Assemble + Tools --> Assemble Assemble --> Results["Cited Evidence Results"] end ``` @@ -493,8 +492,6 @@ debug CSVs (`preds_*.csv`) are saved alongside for troubleshooting. | `content_search_text` | `Text` | Pre-tokenized for BM25 content channel | | `path_search_text` | `Text` | Pre-tokenized for BM25 path channel | | `term_search_text` | `Text` | Pre-tokenized for term/grep channel | -| `content_search_tsv` | `TSVECTOR` (computed) | PostgreSQL GIN index for full-text | -| `path_search_tsv` | `TSVECTOR` (computed) | PostgreSQL GIN index for path | | `source_chunk_path` | `Text` | Original parser path | | `file_path` | `Text` | Asset reference (`images/x.jpg`) | | `chunk_metadata` | `JSON` | Keywords, tokens, connect_to, etc. | @@ -545,23 +542,23 @@ debug CSVs (`preds_*.csv`) are saved alongside for troubleshooting. Core retrieval internals are grouped by ownership: -- `execution/`: request shaping, route selection (classic / mapnav / small_corpus), and public response projection. -- `search/`: `map_unit_discovery` (persisted map-unit BM25 discovery, with a legacy chunk-level PG FTS fallback), scoring, section filters, candidate ranking. +- `execution/`: request shaping, route selection (classic / agent_explore / small_corpus), and public response projection. +- `search/`: `map_unit_discovery` (persisted map-unit BM25 discovery; incomplete or incompatible indexes raise), scoring, section filters, candidate ranking. - `hydration/`: row/path/reference hydration, inline assets, and result assembly. -- `nav/` + `nav_*.py`: map-nav checklist episode (PLANNER / HARVEST / CONTROL). +- `agent_explore/` + `agent_tools/`: default agentic route (cursor_sdk harness). Map-nav is archived under `deprecated/mapnav/`. - `trace/`: `DecisionTraceStep` mapping and `TraceRecorder`. - `graph/`: document graph publication/query support. - `stats/`: retrieval hit recording. ### Two Retrieval Modes -Per-request `use_agentic`: `False` → classic top-K (map-unit BM25); `None`/`True` → map-nav (default). +Per-request `use_agentic`: `False` → classic top-K (map-unit BM25); `None`/`True` → agent_explore (default harness `cursor_sdk`). -#### Classic Mode (map-unit BM25 + legacy FTS fallback) +#### Classic Mode (map-unit BM25) Primary path is `search.map_unit_discovery.map_unit_discovery`: Python BM25Okapi over the persisted `document_map_unit_tokens` index, path and content channels -only, fused by RRF. +only, fused by RRF. An incomplete or incompatible map-unit index raises. ```mermaid flowchart LR @@ -577,15 +574,15 @@ flowchart LR `score = weight / (k + rank + 1)` per channel, summed across channels, `k=60`. There is no scored term channel in this primary path. `term_search_text` / -`term_search_text_lower` are persisted at publish time but are only read by -the **legacy fallback** (`_legacy_chunk_discovery`), which runs only when a -revision's map-unit index is missing or incomplete: a single SQL query -scoring `GREATEST(ts_rank_cd(path_search_tsv), 2 * ts_rank_cd(content_search_tsv))` -OR `term_search_text LIKE '%query%'`, not three independently-ranked channels. +`term_search_text_lower` are persisted at publish time and are read by +`corpus.recall`'s term channel, not by classic discovery. -#### Map-nav Mode (default) +#### Agent-explore Mode (default) -Default agentic path is checklist map-nav (`nav/`): PLANNER (`plan_query`) → HARVEST (`execute_plan` / `harvest`, recursive DISPATCH) → CONTROL (`plan_control`). Episode config lives in `nav_config.py`. Exit bridge expands kept chunks to `referenced_chunks`; `decision_trace` is mapped in `trace/mapnav.py`. Token hard-stop uses `NavConfig.token_limit`. +Default agentic path is `agent_explore`: a `corpus.*` tool loop run by the +resolved harness (`AGENT_EXPLORE_HARNESS`, default `cursor_sdk`). Finish refs +are resolved to chunks, then assembled like classic. Map-nav is archived at +`deprecated/mapnav/` and is no longer a live route. ### Result Assembly diff --git a/apps/api/.env.example b/apps/api/.env.example index ef00d0ff..56743634 100644 --- a/apps/api/.env.example +++ b/apps/api/.env.example @@ -100,8 +100,12 @@ ARK_API_KEY= # Optional retrieval overrides have code defaults. Retrieval is evidence-only: # evidence_text is the primary output and answer_text is always empty. -# Default path is map-nav (PLANNER+HARVEST+CONTROL); set use_agentic=false for -# classic 3-channel RRF. Classic BM25 may use Postgres FTS prefilter: +# Default path is agent_explore (AGENT_EXPLORE_HARNESS=cursor_sdk). +# Set use_agentic=false for classic map-unit BM25. +# AGENT_EXPLORE_HARNESS=cursor_sdk +# CURSOR_API_KEY= # required when harness is cursor_sdk +# AGENT_EXPLORE_CURSOR_MODEL=composer-2.5 +# Classic BM25 may use Postgres FTS prefilter: # RETRIEVAL_POSTGRES_FTS_CANDIDATE_LIMIT=2000 # File handling defaults diff --git a/apps/api/alembic/env.py b/apps/api/alembic/env.py index 8e3a5d5a..021cc507 100644 --- a/apps/api/alembic/env.py +++ b/apps/api/alembic/env.py @@ -40,21 +40,6 @@ "session", } ) -_AUTOGENERATE_IGNORED_COLUMNS: frozenset[tuple[str, str]] = frozenset( - { - ("document_chunks", "content_search_tsv"), - ("document_chunks", "path_search_tsv"), - } -) - - -def _resolve_table_name(object_: object, compare_to: object | None) -> str | None: - for candidate in (object_, compare_to): - table = getattr(candidate, "table", None) - table_name = getattr(table, "name", None) - if isinstance(table_name, str): - return table_name - return None def include_object( @@ -64,14 +49,10 @@ def include_object( reflected: bool, compare_to: object | None, ) -> bool: - """Exclude externally managed auth tables and generated TSV columns.""" - del reflected + """Exclude externally managed auth tables.""" + del object_, compare_to, reflected if type_ == "table" and isinstance(name, str) and name in _EXTERNALLY_MANAGED_TABLES: return False - if type_ == "column" and isinstance(name, str): - table_name = _resolve_table_name(object_, compare_to) - if table_name is not None and (table_name, name) in _AUTOGENERATE_IGNORED_COLUMNS: - return False return True diff --git a/apps/api/alembic/versions/e4f5a6b7c8d9_drop_chunk_search_tsv_columns.py b/apps/api/alembic/versions/e4f5a6b7c8d9_drop_chunk_search_tsv_columns.py new file mode 100644 index 00000000..94316d6e --- /dev/null +++ b/apps/api/alembic/versions/e4f5a6b7c8d9_drop_chunk_search_tsv_columns.py @@ -0,0 +1,55 @@ +"""Drop unused PostgreSQL FTS columns on document_chunks. + +Retrieval no longer reads ``content_search_tsv`` / ``path_search_tsv``. +They were generated from ``content_search_text`` / ``path_search_text`` and +only served the retired FTS fallback. +""" + +from __future__ import annotations + +from collections.abc import Sequence + +from alembic import op + + +revision: str = "e4f5a6b7c8d9" +down_revision: str | None = "d3e4f5a6b7c8" +branch_labels: Sequence[str] | None = None +depends_on: Sequence[str] | None = None + +__all__ = [ + "revision", + "down_revision", + "branch_labels", + "depends_on", + "upgrade", + "downgrade", +] + + +def upgrade() -> None: + op.execute("DROP INDEX IF EXISTS idx_chunk_path_search_tsv") + op.execute("DROP INDEX IF EXISTS idx_chunk_content_search_tsv") + op.execute("ALTER TABLE document_chunks DROP COLUMN IF EXISTS path_search_tsv") + op.execute("ALTER TABLE document_chunks DROP COLUMN IF EXISTS content_search_tsv") + + +def downgrade() -> None: + op.execute( + "ALTER TABLE document_chunks ADD COLUMN content_search_tsv TSVECTOR " + "GENERATED ALWAYS AS (to_tsvector('simple', COALESCE(content_search_text, ''))) " + "STORED" + ) + op.execute( + "ALTER TABLE document_chunks ADD COLUMN path_search_tsv TSVECTOR " + "GENERATED ALWAYS AS (to_tsvector('simple', COALESCE(path_search_text, ''))) " + "STORED" + ) + op.execute( + "CREATE INDEX IF NOT EXISTS idx_chunk_content_search_tsv " + "ON document_chunks USING GIN (content_search_tsv)" + ) + op.execute( + "CREATE INDEX IF NOT EXISTS idx_chunk_path_search_tsv " + "ON document_chunks USING GIN (path_search_tsv)" + ) diff --git a/apps/api/app/api/v1/routes/retrieval.py b/apps/api/app/api/v1/routes/retrieval.py index c7d79595..5d84f57f 100644 --- a/apps/api/app/api/v1/routes/retrieval.py +++ b/apps/api/app/api/v1/routes/retrieval.py @@ -80,8 +80,8 @@ class RetrievalQueryRequest(BaseModel): use_agentic: bool | None = Field( None, description=( - "Map-nav (PLANNER+HARVEST+CONTROL) is the default when unset/true. " - "Set false to force classic 3-channel top-K retrieval." + "Agent explore (cursor_sdk harness by default) when unset/true. " + "Set false to force classic map-unit BM25 top-K retrieval." ), ) conversation_id: str | None = Field( diff --git a/apps/api/main.py b/apps/api/main.py index 0af144c8..16912958 100644 --- a/apps/api/main.py +++ b/apps/api/main.py @@ -104,6 +104,18 @@ async def _redis_ping() -> bool: mcp_server = getattr(app.state, "retrieval_mcp_server", None) mcp_session_manager = getattr(mcp_server, "session_manager", None) + from shared.services.retrieval.agent_explore.harness.resolve import ( + resolve_harness_name, + ) + + if resolve_harness_name() == "cursor_sdk" and not os.environ.get( + "CURSOR_API_KEY", "" + ).strip(): + logger.error( + "Default retrieval harness is cursor_sdk but CURSOR_API_KEY is unset; " + "agentic retrieval requests will fail until the key is set" + ) + logger.info("Document API service started!") if mcp_session_manager is not None: async with mcp_session_manager.run(): diff --git a/apps/api/pyproject.toml b/apps/api/pyproject.toml index cb8aaf85..fb67b582 100644 --- a/apps/api/pyproject.toml +++ b/apps/api/pyproject.toml @@ -23,6 +23,7 @@ dependencies = [ "limits>=5.8,<6", "logfire[celery,fastapi,httpx,sqlalchemy]>=4.25.0", "mcp>=1.27.0", + "cursor-sdk>=1.0.31", ] [dependency-groups] diff --git a/apps/api/scripts/backfill_map_unit_statistics.py b/apps/api/scripts/backfill_map_unit_statistics.py index 86214ef7..1ae6ea79 100644 --- a/apps/api/scripts/backfill_map_unit_statistics.py +++ b/apps/api/scripts/backfill_map_unit_statistics.py @@ -51,7 +51,7 @@ def _bootstrap_python_path() -> None: DocumentMapUnit, DocumentMapUnitIndex, ) -from shared.services.retrieval.nav.knowhere_hybrid import MAP_UNIT_INDEX_FORMAT_VERSION +from shared.services.retrieval.scoring.knowhere_hybrid import MAP_UNIT_INDEX_FORMAT_VERSION @dataclass(frozen=True) diff --git a/apps/api/tests/contract/test_retrieval_classic_map_unit_contract.py b/apps/api/tests/contract/test_retrieval_classic_map_unit_contract.py index fe5b732c..d42148d8 100644 --- a/apps/api/tests/contract/test_retrieval_classic_map_unit_contract.py +++ b/apps/api/tests/contract/test_retrieval_classic_map_unit_contract.py @@ -6,10 +6,11 @@ from uuid import uuid4 import pytest -from httpx import AsyncClient, Response +from httpx import AsyncClient from sqlalchemy import Engine, event, select from shared.models.database.document import DocumentMapUnit +from shared.services.retrieval.hydration.connected import hydrate_connected_target_rows from shared.services.retrieval.publication_content import ( replace_document_revision_content, ) @@ -395,100 +396,62 @@ async def test_classic_discovery_returns_empty_for_an_empty_revision_pin( assert result.payload["fused_rows"] == [] -async def test_classic_route_falls_back_for_v1_index_with_excluded_document( +async def test_classic_route_raises_for_v1_index( developer_api_client_factory: Callable[ [], AbstractAsyncContextManager[AsyncClient] ], ) -> None: identifier = uuid4().hex[:8] - namespace = f"classic-v1-fallback-{identifier}" - legacy_queries: list[str] = [] - - def capture_legacy_query( - _connection: Any, - _cursor: Any, - statement: str, - _parameters: Any, - _context: Any, - _executemany: bool, - ) -> None: - if "plainto_tsquery('simple'" in statement: - legacy_queries.append(statement) - - event.listen(Engine, "before_cursor_execute", capture_legacy_query) - try: - async with developer_api_client_factory() as api_client: - first = await _publish_document( - namespace=namespace, - source_file_name="legacy-fallback.pdf", - chunks=[ - { - "chunk_id": f"legacy-hit-{identifier}", - "type": "text", - "content": "legacy fallback marker", - "path": "legacy-fallback.pdf/Root/Section/body", - "order": 1, - "metadata": {}, - }, - { - "chunk_id": f"legacy-filler-a-{identifier}", - "type": "text", - "content": "unrelated legacy filler a", - "path": "legacy-fallback.pdf/Root/Section/a", - "order": 2, - "metadata": {}, - }, - { - "chunk_id": f"legacy-filler-b-{identifier}", - "type": "text", - "content": "unrelated legacy filler b", - "path": "legacy-fallback.pdf/Root/Section/b", - "order": 3, - "metadata": {}, - }, - ], - ) - excluded = await _publish_document( - namespace=namespace, - source_file_name="excluded.pdf", - chunks=[ - { - "chunk_id": f"excluded-{identifier}", - "type": "text", - "content": "unrelated filler", - "path": "excluded.pdf/Root/Section/body", - "order": 1, - "metadata": {}, - } - ], - ) - await ContractDatabase.execute( - """ - UPDATE document_map_unit_indexes - SET format_version = 1 - WHERE document_id = :document_id - """, - {"document_id": first["document_id"]}, - ) - response = await api_client.post( + namespace = f"classic-v1-raise-{identifier}" + async with developer_api_client_factory() as api_client: + first = await _publish_document( + namespace=namespace, + source_file_name="legacy-index.pdf", + chunks=[ + { + "chunk_id": f"legacy-hit-{identifier}", + "type": "text", + "content": "legacy index marker", + "path": "legacy-index.pdf/Root/Section/body", + "order": 1, + "metadata": {}, + }, + { + "chunk_id": f"legacy-filler-a-{identifier}", + "type": "text", + "content": "unrelated filler a", + "path": "legacy-index.pdf/Root/Section/a", + "order": 2, + "metadata": {}, + }, + { + "chunk_id": f"legacy-filler-b-{identifier}", + "type": "text", + "content": "unrelated filler b", + "path": "legacy-index.pdf/Root/Section/b", + "order": 3, + "metadata": {}, + }, + ], + ) + await ContractDatabase.execute( + """ + UPDATE document_map_unit_indexes + SET format_version = 1 + WHERE document_id = :document_id + """, + {"document_id": first["document_id"]}, + ) + with pytest.raises(RuntimeError, match="map-unit index is incomplete"): + await api_client.post( "/api/v1/retrieval/query", json={ "namespace": namespace, - "query": "legacy fallback marker", + "query": "legacy index marker", "top_k": 1, "use_agentic": False, - "exclude_document_ids": [excluded["document_id"]], }, ) - finally: - event.remove(Engine, "before_cursor_execute", capture_legacy_query) - - assert response.status_code == 200 - body = cast(dict[str, object], response.json()) - results = cast(list[dict[str, object]], body["results"]) - assert len(results) == 1 - assert results[0]["chunk_id"] == f"legacy-hit-{identifier}" - assert legacy_queries async def test_classic_discovery_preserves_results_before_statistics_backfill( @@ -604,133 +567,95 @@ def result_signature(result: DiscoveryResult) -> list[tuple[Any, ...]]: @pytest.mark.parametrize( "incomplete_index_kind", ["legacy_format", "missing_index", "missing_tokens"] ) -async def test_unfiltered_classic_route_falls_back_when_selective_rows_are_unavailable( +async def test_unfiltered_classic_route_raises_when_index_is_unusable( developer_api_client_factory: Callable[ [], AbstractAsyncContextManager[AsyncClient] ], incomplete_index_kind: str, ) -> None: identifier: str = uuid4().hex[:8] - namespace: str = f"classic-token-fallback-{incomplete_index_kind}-{identifier}" - legacy_queries: list[str] = [] - - def capture_legacy_query( - _connection: object, - _cursor: object, - statement: str, - _parameters: object, - _context: object, - _executemany: bool, - ) -> None: - if "plainto_tsquery('simple'" in statement: - legacy_queries.append(statement) - - event.listen(Engine, "before_cursor_execute", capture_legacy_query) - try: - async with developer_api_client_factory() as api_client: - document: dict[str, str] = await _publish_document( - namespace=namespace, - source_file_name="legacy-token-hash.pdf", - chunks=[ - { - "chunk_id": f"legacy-token-hit-{identifier}", - "type": "text", - "content": "legacy token fallback marker", - "path": "legacy-token-hash.pdf/Root/Section/body", - "order": 1, - "metadata": {}, - }, - { - "chunk_id": f"legacy-token-filler-a-{identifier}", - "type": "text", - "content": "unrelated legacy filler a", - "path": "legacy-token-hash.pdf/Root/Section/a", - "order": 2, - "metadata": {}, - }, - { - "chunk_id": f"legacy-token-filler-b-{identifier}", - "type": "text", - "content": "unrelated legacy filler b", - "path": "legacy-token-hash.pdf/Root/Section/b", - "order": 3, - "metadata": {}, - }, - ], + namespace: str = f"classic-unusable-{incomplete_index_kind}-{identifier}" + async with developer_api_client_factory() as api_client: + document: dict[str, str] = await _publish_document( + namespace=namespace, + source_file_name="unusable-index.pdf", + chunks=[ + { + "chunk_id": f"unusable-hit-{identifier}", + "type": "text", + "content": "unusable index marker", + "path": "unusable-index.pdf/Root/Section/body", + "order": 1, + "metadata": {}, + }, + { + "chunk_id": f"unusable-filler-a-{identifier}", + "type": "text", + "content": "unrelated filler a", + "path": "unusable-index.pdf/Root/Section/a", + "order": 2, + "metadata": {}, + }, + { + "chunk_id": f"unusable-filler-b-{identifier}", + "type": "text", + "content": "unrelated filler b", + "path": "unusable-index.pdf/Root/Section/b", + "order": 3, + "metadata": {}, + }, + ], + ) + if incomplete_index_kind == "legacy_format": + await ContractDatabase.execute( + """ + UPDATE document_map_unit_indexes + SET format_version = 1 + WHERE document_id = :document_id + """, + {"document_id": document["document_id"]}, ) - if incomplete_index_kind == "legacy_format": - await ContractDatabase.execute( - """ - UPDATE document_map_unit_indexes - SET format_version = 1 + elif incomplete_index_kind == "missing_tokens": + await ContractDatabase.execute( + """ + DELETE FROM document_map_unit_tokens + WHERE map_unit_id IN ( + SELECT id + FROM document_map_units WHERE document_id = :document_id - """, - {"document_id": document["document_id"]}, - ) - await ContractDatabase.execute( - """ - UPDATE document_map_unit_tokens - SET token_hash = :legacy_token_hash - WHERE map_unit_id IN ( - SELECT id - FROM document_map_units - WHERE document_id = :document_id - ) - """, - { - "document_id": document["document_id"], - "legacy_token_hash": "legacy-token-hash", - }, ) - elif incomplete_index_kind == "missing_tokens": - await ContractDatabase.execute( - """ - DELETE FROM document_map_unit_tokens - WHERE map_unit_id IN ( - SELECT id - FROM document_map_units - WHERE document_id = :document_id - ) - """, - {"document_id": document["document_id"]}, - ) - else: - await ContractDatabase.execute( - """ - DELETE FROM document_map_unit_indexes + """, + {"document_id": document["document_id"]}, + ) + else: + await ContractDatabase.execute( + """ + DELETE FROM document_map_unit_indexes + WHERE document_id = :document_id + """, + {"document_id": document["document_id"]}, + ) + await ContractDatabase.execute( + """ + DELETE FROM document_map_unit_tokens + WHERE map_unit_id IN ( + SELECT id + FROM document_map_units WHERE document_id = :document_id - """, - {"document_id": document["document_id"]}, ) - await ContractDatabase.execute( - """ - DELETE FROM document_map_unit_tokens - WHERE map_unit_id IN ( - SELECT id - FROM document_map_units - WHERE document_id = :document_id - ) - """, - {"document_id": document["document_id"]}, - ) - response: Response = await api_client.post( + """, + {"document_id": document["document_id"]}, + ) + with pytest.raises(RuntimeError, match="map-unit index is incomplete"): + await api_client.post( "/api/v1/retrieval/query", json={ "namespace": namespace, - "query": "legacy token fallback marker", + "query": "unusable index marker", "top_k": 1, "use_agentic": False, }, ) - finally: - event.remove(Engine, "before_cursor_execute", capture_legacy_query) - - assert response.status_code == 200 - body = cast(dict[str, object], response.json()) - results = cast(list[dict[str, object]], body["results"]) - assert len(results) == 1 - assert results[0]["chunk_id"] == f"legacy-token-hit-{identifier}" - assert legacy_queries async def test_classic_route_image_filter_scores_only_units_with_images( @@ -856,6 +781,78 @@ async def test_classic_route_image_filter_scores_only_units_with_images( assert results[0]["chunk_type"] == "image" +async def test_connected_hydration_does_not_load_legacy_job_chunks( + developer_api_client_factory: Callable[ + [], AbstractAsyncContextManager[AsyncClient] + ], +) -> None: + identifier = uuid4().hex[:8] + namespace = f"connected-job-{identifier}" + statements: list[str] = [] + + def capture_job_chunk_query( + _connection: Any, + _cursor: Any, + statement: str, + _parameters: Any, + _context: Any, + _executemany: bool, + ) -> None: + if "job_chunks" in statement.lower(): + statements.append(statement) + + async with developer_api_client_factory(): + published = await _publish_document( + namespace=namespace, + source_file_name="connected.pdf", + chunks=[ + { + "chunk_id": "body-connected", + "type": "text", + "content": "body connected evidence", + "path": "connected.pdf/Root/Section/body", + "order": 1, + "metadata": {"connect_to": [{"target": "asset-connected"}]}, + }, + { + "chunk_id": "asset-connected", + "type": "image", + "content": "asset connected summary", + "path": "images/asset-connected.png", + "order": 2, + "file_path": "images/asset-connected.png", + "metadata": {}, + }, + ], + ) + event.listen(Engine, "before_cursor_execute", capture_job_chunk_query) + try: + async with contract_db_session() as db: + hydrated = await hydrate_connected_target_rows( + db=db, + rows=[ + { + "document_id": published["document_id"], + "job_result_id": published["job_result_id"], + "chunk_id": "body-connected", + "chunk_type": "text", + "chunk_metadata": { + "connect_to": [{"target": "asset-connected"}] + }, + } + ], + exclude_document_ids=[], + exclude_sections=[], + revision_pins={published["document_id"]: published["job_result_id"]}, + ) + finally: + event.remove(Engine, "before_cursor_execute", capture_job_chunk_query) + + assert [row["chunk_id"] for row in hydrated] == ["asset-connected"] + assert hydrated[0]["job_id"] == published["job_id"] + assert statements == [] + + def _publish_revision_with_generation_lock( sync_db: Any, *, diff --git a/apps/api/tests/contract/test_retrieval_contract.py b/apps/api/tests/contract/test_retrieval_contract.py index 90dc7e4f..49f676b6 100644 --- a/apps/api/tests/contract/test_retrieval_contract.py +++ b/apps/api/tests/contract/test_retrieval_contract.py @@ -245,20 +245,38 @@ async def test_retrieval_should_use_classic_topk_when_agentic_is_false( [], AbstractAsyncContextManager[AsyncClient] ], ) -> None: + from tests.contract.test_retrieval_classic_map_unit_contract import ( + _publish_document, + ) + async with developer_api_client_factory() as api_client: - await _seed_retrieval_document( - user_id="local-dev-user", + await _publish_document( namespace="contract-agentic-only", source_file_name="a.pdf", - section_path="agentic/a", - content="same ranking marker a", - ) - await _seed_retrieval_document( - user_id="local-dev-user", + chunks=[ + { + "chunk_id": "classic-a", + "type": "text", + "content": "same ranking marker a", + "path": "a.pdf/Root/agentic/a", + "order": 1, + "metadata": {}, + } + ], + ) + await _publish_document( namespace="contract-agentic-only", source_file_name="b.pdf", - section_path="agentic/b", - content="same ranking marker b", + chunks=[ + { + "chunk_id": "classic-b", + "type": "text", + "content": "same ranking marker b", + "path": "b.pdf/Root/agentic/b", + "order": 1, + "metadata": {}, + } + ], ) response = await api_client.post( "/api/v1/retrieval/query", @@ -413,62 +431,59 @@ async def test_should_exclude_matching_sections_from_the_response( -def _episode_keeping_chunks( +def _episode_keeping_refs( *, documents: list[dict[str, str]], - evidence_text: str = "mapnav evidence", + notes: str = "", ) -> Any: - """Build a minimal EpisodeResult whose kept_chunks use real seeded chunk_ids.""" - from shared.services.retrieval.nav._compat import AgentStep, Chunk, EpisodeResult + from shared.services.retrieval.agent_explore.types import AgentStep, EpisodeResult - kept: list[Chunk] = [] - scored: list[tuple[Chunk, float]] = [] + refs: list[dict[str, str]] = [] for doc in documents: - chunk = Chunk( - node_id=doc["chunk_id"], - doc_id=doc["document_id"], - text=str(doc.get("content") or evidence_text), - line_ids=(0,), - section_id=doc.get("section_id"), - ) - kept.append(chunk) - scored.append((chunk, 1.0)) + ref = {"document_id": doc["document_id"]} + if doc.get("chunk_id"): + ref["chunk_id"] = doc["chunk_id"] + if doc.get("section_path"): + ref["section_path"] = doc["section_path"] + refs.append(ref) return EpisodeResult( - representation="mapnav", + refs=refs, + notes=notes, steps=[ AgentStep( - step_idx=1, - action="query_plan", - detail={ - "plan": {"subgoals": [{"id": "s1"}], "coverage_checklist": []}, - "token_limit": 100000, - "tokens_used_total": 1, - "tokens_used_delta": 1, - "elapsed_ms": 1, - }, + step_index=1, + tool_name="finish", + tool_args={"refs": refs}, + observation_text=notes or "done", + error=None, + elapsed_ms=1, + tokens_used_delta=1, + tokens_used_total=1, ) ], - scored_chunks=scored, - kept_chunks=kept, - evidence_text=evidence_text, - evidence_chars_actual=len(evidence_text), - retrieved_nodes=[d["chunk_id"] for d in documents], - stop_reason="completed", + stop_reason="finished", + tokens_used=1, + model_name="test", ) -def _patch_run_nav_episode(monkeypatch: MonkeyPatch, episode: Any) -> None: - def _fake_run_nav_episode(*_args: Any, **_kwargs: Any) -> Any: - return episode +class _FakeHarness: + def __init__(self, episode: Any) -> None: + self._episode = episode + + async def run_episode(self, **_kwargs: Any) -> Any: + return self._episode + +def _patch_harness(monkeypatch: MonkeyPatch, episode: Any) -> None: monkeypatch.setattr( - "shared.services.retrieval.nav.run_nav_episode", - _fake_run_nav_episode, + "shared.services.retrieval.agent_explore.harness.resolve_harness", + lambda: _FakeHarness(episode), ) @pytest.mark.asyncio -async def test_mapnav_retrieval_should_return_seeded_chunk_via_fake_episode( +async def test_agent_explore_retrieval_should_return_seeded_chunk_via_fake_episode( developer_api_client_factory: Callable[ [], AbstractAsyncContextManager[AsyncClient] ], @@ -477,31 +492,30 @@ async def test_mapnav_retrieval_should_return_seeded_chunk_via_fake_episode( async with developer_api_client_factory() as api_client: target = await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-seed", + namespace="contract-explore-seed", source_file_name="target.pdf", section_path="Findings", - content="mapnav seeded EBITDA marker content", + content="explore seeded EBITDA marker content", ) await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-seed", + namespace="contract-explore-seed", source_file_name="filler.pdf", section_path="filler/section", content="unrelated filler content", ) - target_with_content = {**target, "content": "mapnav seeded EBITDA marker content"} - _patch_run_nav_episode( + _patch_harness( monkeypatch, - _episode_keeping_chunks( - documents=[target_with_content], - evidence_text="mapnav seeded EBITDA marker content", + _episode_keeping_refs( + documents=[target], + notes="explore seeded EBITDA marker content", ), ) response = await api_client.post( "/api/v1/retrieval/query", json={ - "namespace": "contract-mapnav-seed", + "namespace": "contract-explore-seed", "query": "EBITDA marker", "top_k": 1, "use_agentic": True, @@ -513,23 +527,17 @@ async def test_mapnav_retrieval_should_return_seeded_chunk_via_fake_episode( referenced_chunks = cast(list[dict[str, object]], response_json["referenced_chunks"]) results = cast(list[dict[str, object]], response_json["results"]) - assert response_json["router_used"] == "mapnav" - assert response_json["stop_reason"] == "completed" + assert response_json["router_used"] == "agent_explore" + assert response_json["stop_reason"] == "finished" assert isinstance(response_json.get("decision_trace"), list) assert response_json["decision_trace"] - assert response_json["decision_trace"][-1]["phase"] == "terminal" - assert { - "chunk_id": target["chunk_id"], - "document_id": target["document_id"], - "chunk_type": "text", - "section_path": target["section_path"], - "file_path": "", - "job_id": target["job_id"], - } in [ - {k: v for k, v in ref.items() if k != "score"} + assert response_json["decision_trace"][-1]["phase"] == "finish" + assert any( + ref.get("chunk_id") == target["chunk_id"] + and ref.get("document_id") == target["document_id"] for ref in referenced_chunks - ] - assert results[0]["content"] == "mapnav seeded EBITDA marker content" + ) + assert results[0]["content"] == "explore seeded EBITDA marker content" assert results[0]["source"] == { "document_id": target["document_id"], "source_file_name": "target.pdf", @@ -538,63 +546,80 @@ async def test_mapnav_retrieval_should_return_seeded_chunk_via_fake_episode( @pytest.mark.asyncio -async def test_mapnav_retrieval_should_not_hydrate_references_outside_request_scope( +async def test_agentic_router_env_mapnav_is_ignored( developer_api_client_factory: Callable[ [], AbstractAsyncContextManager[AsyncClient] ], monkeypatch: MonkeyPatch, ) -> None: + monkeypatch.setenv("RETRIEVAL_AGENTIC_ROUTER", "mapnav") async with developer_api_client_factory() as api_client: + target = await _seed_retrieval_document( + user_id="local-dev-user", + namespace="contract-explore-env", + source_file_name="target.pdf", + section_path="Findings", + content="env ignored content", + ) await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-visible", + namespace="contract-explore-env", + source_file_name="filler.pdf", + section_path="filler/section", + content="unrelated filler content", + ) + _patch_harness( + monkeypatch, + _episode_keeping_refs(documents=[target], notes="env ignored"), + ) + response = await api_client.post( + "/api/v1/retrieval/query", + json={ + "namespace": "contract-explore-env", + "query": "ignored", + "top_k": 1, + "use_agentic": True, + }, + ) + assert response.status_code == 200 + assert cast(dict[str, object], response.json())["router_used"] == "agent_explore" + + +@pytest.mark.asyncio +async def test_agent_explore_should_not_hydrate_references_outside_request_scope( + developer_api_client_factory: Callable[ + [], AbstractAsyncContextManager[AsyncClient] + ], + monkeypatch: MonkeyPatch, +) -> None: + async with developer_api_client_factory() as api_client: + await _seed_retrieval_document( + user_id="local-dev-user", + namespace="contract-explore-visible", source_file_name="visible.pdf", section_path="visible/section", content="visible scoped content", ) await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-visible", + namespace="contract-explore-visible", source_file_name="visible-filler.pdf", section_path="visible/filler", content="visible scoped filler content", ) foreign = await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-foreign", + namespace="contract-explore-foreign", source_file_name="foreign.pdf", section_path="foreign/section", content="foreign scoped content should not leak", ) - - def _fake_bridge(_episode: Any, _snapshot: Any) -> tuple[list[dict[str, Any]], dict[str, float]]: - return ( - [ - { - "chunk_id": foreign["chunk_id"], - "document_id": foreign["document_id"], - "chunk_type": "text", - "section_path": foreign["section_path"], - "file_path": None, - "job_id": foreign["job_id"], - } - ], - {foreign["chunk_id"]: 1.0}, - ) - - _patch_run_nav_episode( - monkeypatch, - _episode_keeping_chunks(documents=[{**foreign, "content": "x"}]), - ) - monkeypatch.setattr( - "shared.services.retrieval.nav_bridge.build_referenced_chunks", - _fake_bridge, - ) + _patch_harness(monkeypatch, _episode_keeping_refs(documents=[foreign])) response = await api_client.post( "/api/v1/retrieval/query", json={ - "namespace": "contract-mapnav-visible", + "namespace": "contract-explore-visible", "query": "visible", "top_k": 1, "use_agentic": True, @@ -603,13 +628,13 @@ def _fake_bridge(_episode: Any, _snapshot: Any) -> tuple[list[dict[str, Any]], d assert response.status_code == 200 response_json = cast(dict[str, object], response.json()) - assert response_json["router_used"] == "mapnav" + assert response_json["router_used"] == "agent_explore" assert response_json["referenced_chunks"] == [] assert response_json["results"] == [] @pytest.mark.asyncio -async def test_mapnav_retrieval_should_drop_references_with_mismatched_section_path( +async def test_agent_explore_should_drop_references_with_mismatched_section_path( developer_api_client_factory: Callable[ [], AbstractAsyncContextManager[AsyncClient] ], @@ -618,47 +643,28 @@ async def test_mapnav_retrieval_should_drop_references_with_mismatched_section_p async with developer_api_client_factory() as api_client: visible = await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-section-mismatch", + namespace="contract-explore-section-mismatch", source_file_name="visible.pdf", section_path="visible/section", content="visible scoped content", ) await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-section-mismatch", + namespace="contract-explore-section-mismatch", source_file_name="filler.pdf", section_path="filler/section", content="filler content", ) - - def _fake_bridge(_episode: Any, _snapshot: Any) -> tuple[list[dict[str, Any]], dict[str, float]]: - return ( - [ - { - "chunk_id": visible["chunk_id"], - "document_id": visible["document_id"], - "chunk_type": "text", - "section_path": "wrong/section/path", - "file_path": None, - "job_id": visible["job_id"], - } - ], - {visible["chunk_id"]: 1.0}, - ) - - _patch_run_nav_episode( - monkeypatch, - _episode_keeping_chunks(documents=[{**visible, "content": "x"}]), - ) - monkeypatch.setattr( - "shared.services.retrieval.nav_bridge.build_referenced_chunks", - _fake_bridge, - ) + mismatched = { + "document_id": visible["document_id"], + "section_path": "wrong/section/path", + } + _patch_harness(monkeypatch, _episode_keeping_refs(documents=[mismatched])) response = await api_client.post( "/api/v1/retrieval/query", json={ - "namespace": "contract-mapnav-section-mismatch", + "namespace": "contract-explore-section-mismatch", "query": "visible", "top_k": 1, "use_agentic": True, @@ -667,13 +673,13 @@ def _fake_bridge(_episode: Any, _snapshot: Any) -> tuple[list[dict[str, Any]], d assert response.status_code == 200 response_json = cast(dict[str, object], response.json()) - assert response_json["router_used"] == "mapnav" + assert response_json["router_used"] == "agent_explore" assert response_json["referenced_chunks"] == [] assert response_json["results"] == [] @pytest.mark.asyncio -async def test_mapnav_retrieval_should_fail_when_final_hydration_db_fails( +async def test_agent_explore_should_fail_when_final_hydration_db_fails( developer_api_client_factory: Callable[ [], AbstractAsyncContextManager[AsyncClient] ], @@ -685,26 +691,21 @@ async def fail_final_hydration(**_kwargs: object) -> object: async with developer_api_client_factory() as api_client: visible = await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-hydration-failure", + namespace="contract-explore-hydration-failure", source_file_name="visible.pdf", section_path="visible/section", content="visible scoped content", ) await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-hydration-failure", + namespace="contract-explore-hydration-failure", source_file_name="filler.pdf", section_path="filler/section", content="filler content", ) from shared.services.retrieval.execution import routes as retrieval_routes - _patch_run_nav_episode( - monkeypatch, - _episode_keeping_chunks( - documents=[{**visible, "content": "visible scoped content"}] - ), - ) + _patch_harness(monkeypatch, _episode_keeping_refs(documents=[visible])) monkeypatch.setattr( retrieval_routes, "resolve_workflow_references", @@ -718,7 +719,7 @@ async def fail_final_hydration(**_kwargs: object) -> object: await api_client.post( "/api/v1/retrieval/query", json={ - "namespace": "contract-mapnav-hydration-failure", + "namespace": "contract-explore-hydration-failure", "query": "visible", "top_k": 1, "use_agentic": True, @@ -727,7 +728,7 @@ async def fail_final_hydration(**_kwargs: object) -> object: @pytest.mark.asyncio -async def test_mapnav_should_preserve_same_chunk_id_across_documents( +async def test_agent_explore_should_preserve_same_chunk_id_across_documents( developer_api_client_factory: Callable[ [], AbstractAsyncContextManager[AsyncClient] ], @@ -738,7 +739,7 @@ async def test_mapnav_should_preserve_same_chunk_id_across_documents( async with developer_api_client_factory() as api_client: first = await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-shared-chunk", + namespace="contract-explore-shared-chunk", source_file_name="first.pdf", section_path="shared/first", content="first shared reference content", @@ -746,34 +747,29 @@ async def test_mapnav_should_preserve_same_chunk_id_across_documents( ) second_doc = await _seed_retrieval_document( user_id="local-dev-user", - namespace="contract-mapnav-shared-chunk", + namespace="contract-explore-shared-chunk", source_file_name="second.pdf", section_path="shared/second-host", content="host content for second document", ) second = await _seed_retrieval_chunk_for_existing_document( user_id="local-dev-user", - namespace="contract-mapnav-shared-chunk", + namespace="contract-explore-shared-chunk", document=second_doc, section_path="shared/second", content="second shared reference content", chunk_id=shared_chunk_id, ) - _patch_run_nav_episode( + _patch_harness( monkeypatch, - _episode_keeping_chunks( - documents=[ - {**first, "content": "first shared reference content"}, - {**second, "content": "second shared reference content"}, - ] - ), + _episode_keeping_refs(documents=[first, second]), ) response = await api_client.post( "/api/v1/retrieval/query", json={ - "namespace": "contract-mapnav-shared-chunk", + "namespace": "contract-explore-shared-chunk", "query": "shared reference", "top_k": 1, "use_agentic": True, @@ -785,7 +781,7 @@ async def test_mapnav_should_preserve_same_chunk_id_across_documents( referenced_chunks = cast(list[dict[str, object]], response_json["referenced_chunks"]) results = cast(list[dict[str, object]], response_json["results"]) - assert response_json["router_used"] == "mapnav" + assert response_json["router_used"] == "agent_explore" assert len(referenced_chunks) == 2 assert {ref["document_id"] for ref in referenced_chunks} == { first["document_id"], diff --git a/apps/worker/.env.example b/apps/worker/.env.example index 46a347c8..3b73cf4f 100644 --- a/apps/worker/.env.example +++ b/apps/worker/.env.example @@ -95,8 +95,12 @@ ARK_API_KEY= # Optional retrieval overrides have code defaults. Retrieval is evidence-only: # evidence_text is the primary output and answer_text is always empty. -# Default path is map-nav (PLANNER+HARVEST+CONTROL); set use_agentic=false for -# classic 3-channel RRF. Classic BM25 may use Postgres FTS prefilter: +# Default path is agent_explore (AGENT_EXPLORE_HARNESS=cursor_sdk). +# Set use_agentic=false for classic map-unit BM25. +# AGENT_EXPLORE_HARNESS=cursor_sdk +# CURSOR_API_KEY= # required when harness is cursor_sdk +# AGENT_EXPLORE_CURSOR_MODEL=composer-2.5 +# Classic BM25 may use Postgres FTS prefilter: # RETRIEVAL_POSTGRES_FTS_CANDIDATE_LIMIT=2000 # Required for specific features: billing and analytics diff --git a/apps/worker/pyproject.toml b/apps/worker/pyproject.toml index 5593b776..8cb35cdb 100644 --- a/apps/worker/pyproject.toml +++ b/apps/worker/pyproject.toml @@ -30,10 +30,8 @@ dependencies = [ "rapidocr-onnxruntime>=1.4.4", ] -# AGENT_EXPLORE_HARNESS=cursor_sdk (shared/services/retrieval/agent_explore/ -# harness/cursor_harness.py). Not in the base dependency set: this harness -# is an alternative to the default OpenAI-compatible one (openai_harness.py), -# not required for it. Install with `uv sync --extra cursor-harness`. +# Production retrieval runs in apps/api, where cursor-sdk is a base +# dependency. This extra is only for worker debug/eval scripts. [project.optional-dependencies] cursor-harness = [ "cursor-sdk>=1.0.31", diff --git a/apps/worker/scripts/run_agentic_router_eval.py b/apps/worker/scripts/run_agentic_router_eval.py index 4f4932dc..752ed091 100644 --- a/apps/worker/scripts/run_agentic_router_eval.py +++ b/apps/worker/scripts/run_agentic_router_eval.py @@ -1,16 +1,14 @@ -"""Phase 4 router comparison: mapnav vs agent_explore on a fixed query set. +"""Smoke-run agent_explore on a fixed query set. Reads ``fixtures/changheba_archive_eval_queries.json`` (sourced from ``zh_档案知识库测试样例.docx``) and runs each query through -``run_retrieval_route`` directly — bypassing the Redis result cache, which -does not key on ``RETRIEVAL_AGENTIC_ROUTER`` and would otherwise return the -first router's answer for both runs of the same query. +``run_retrieval_route`` directly, bypassing the Redis result cache. Usage: cd apps/worker uv run python scripts/run_agentic_router_eval.py uv run python scripts/run_agentic_router_eval.py --query-id q05 - uv run python scripts/run_agentic_router_eval.py --router agent_explore + uv run python scripts/run_agentic_router_eval.py --use-agentic false """ from __future__ import annotations @@ -21,7 +19,6 @@ import os import sys import time -from contextlib import contextmanager from dataclasses import dataclass from datetime import datetime from pathlib import Path @@ -35,36 +32,17 @@ sys.path.insert(0, str(_SHARED_PYTHON)) sys.path.insert(0, str(_SCRIPT_DIR.parent)) -load_dotenv(_SCRIPT_DIR.parent / ".env") +load_dotenv(_SCRIPT_DIR.parent / ".env", override=True) os.environ.setdefault("LOCAL_DEBUG", "0") os.environ.setdefault("LLM_MOCK_ENABLED", "false") FIXTURE_PATH = _SCRIPT_DIR / "fixtures" / "changheba_archive_eval_queries.json" -ROUTERS = ("mapnav", "agent_explore") +_MODES = ("classic", "agent_explore") TOP_K = 10 -@contextmanager -def temporary_env(overrides: dict[str, str]): - previous = {key: os.environ.get(key) for key in overrides} - os.environ.update(overrides) - try: - yield - finally: - for key, old in previous.items(): - if old is None: - os.environ.pop(key, None) - else: - os.environ[key] = old - - -def _count_llm_steps(decision_trace: list[dict[str, Any]], router: str) -> int: - if router == "mapnav": - return sum( - 1 - for step in decision_trace - if step.get("phase") in ("plan", "harvest", "plan_control") - ) +def _count_llm_steps(decision_trace: list[dict[str, Any]], mode: str) -> int: + del mode return sum( 1 for step in decision_trace @@ -82,7 +60,7 @@ def _keyword_hits(evidence_text: str, keywords: list[str]) -> tuple[int, list[st @dataclass class RunMetrics: query_id: str - router: str + router: str # "classic" | "agent_explore" total_ms: int router_used: str stop_reason: str @@ -103,6 +81,7 @@ async def _run_one( query: str, query_id: str, router: str, + use_agentic: bool, expected_keywords: list[str], ) -> RunMetrics: from dataclasses import replace @@ -121,42 +100,41 @@ async def _run_one( error: str | None = None response: dict[str, Any] = {} try: - with temporary_env({"RETRIEVAL_AGENTIC_ROUTER": router}): - async with get_db_context() as db: - request = RetrievalQuery.from_parameters( - db=db, - user_id=user_id, - namespace=namespace, - query=query, - top_k=TOP_K, - exclude_document_ids=[], - exclude_sections=[], - use_agentic=True, - ) + async with get_db_context() as db: + request = RetrievalQuery.from_parameters( + db=db, + user_id=user_id, + namespace=namespace, + query=query, + top_k=TOP_K, + exclude_document_ids=[], + exclude_sections=[], + use_agentic=use_agentic, + ) + revision_pins = await capture_revision_pins( + db, user_id=user_id, namespace=namespace + ) + if not await is_revision_generation_stable( + db, + user_id=user_id, + namespace=namespace, + pins=revision_pins, + ): revision_pins = await capture_revision_pins( db, user_id=user_id, namespace=namespace ) - if not await is_revision_generation_stable( - db, - user_id=user_id, - namespace=namespace, - pins=revision_pins, - ): - revision_pins = await capture_revision_pins( - db, user_id=user_id, namespace=namespace - ) - effective_recall_k = ( - request.internal_recall_k - if request.internal_recall_k is not None - else TOP_K * INTERNAL_RECALL_K_MULTIPLIER - ) - context = replace( - request.build_route_context(), - revision_pins=revision_pins, - effective_recall_k=effective_recall_k, - ) - outcome = await run_retrieval_route(context) - response = await project_public_retrieval_response(outcome.response) + effective_recall_k = ( + request.internal_recall_k + if request.internal_recall_k is not None + else TOP_K * INTERNAL_RECALL_K_MULTIPLIER + ) + context = replace( + request.build_route_context(), + revision_pins=revision_pins, + effective_recall_k=effective_recall_k, + ) + outcome = await run_retrieval_route(context) + response = await project_public_retrieval_response(outcome.response) except Exception as exc: # noqa: BLE001 - eval runner must continue error = f"{type(exc).__name__}: {exc}" @@ -201,7 +179,7 @@ def _render_markdown( for item in fixture["queries"]: qid = item["id"] short = item["query"][:28] + ("…" if len(item["query"]) > 28 else "") - for router in ROUTERS: + for router in _MODES: r = by_key.get((qid, router)) if r is None: continue @@ -212,7 +190,7 @@ def _render_markdown( f"{r.llm_steps} | {r.refs} | {kw} | {stop} |\n" ) - mapnav_ms = [r.total_ms for r in runs if r.router == "mapnav" and not r.error] + classic_ms = [r.total_ms for r in runs if r.router == "classic" and not r.error] agent_ms = [r.total_ms for r in runs if r.router == "agent_explore" and not r.error] def _p50(values: list[int]) -> int | None: @@ -224,7 +202,7 @@ def _p50(values: list[int]) -> int | None: lines.extend( [ "\n## Aggregate latency (successful runs only)\n", - f"- mapnav p50: {_p50(mapnav_ms)} ms ({len(mapnav_ms)} runs)\n", + f"- classic p50: {_p50(classic_ms)} ms ({len(classic_ms)} runs)\n", f"- agent_explore p50: {_p50(agent_ms)} ms ({len(agent_ms)} runs)\n", "\n## Notes\n", "- Runs bypass Redis retrieval cache (direct ``run_retrieval_route``).\n", @@ -238,7 +216,7 @@ def _p50(values: list[int]) -> int | None: async def main() -> None: - parser = argparse.ArgumentParser(description="Compare mapnav vs agent_explore") + parser = argparse.ArgumentParser(description="Smoke-run agent_explore eval fixture") parser.add_argument( "--fixture", default=str(FIXTURE_PATH), @@ -257,10 +235,10 @@ async def main() -> None: help="Run only these query ids (repeatable, e.g. --query-id q01)", ) parser.add_argument( - "--router", - choices=[*ROUTERS, "both"], + "--use-agentic", + choices=["true", "false", "both"], default="both", - help="Which router(s) to run", + help="classic (false), agent_explore (true), or both", ) args = parser.parse_args() @@ -270,7 +248,12 @@ async def main() -> None: allowed = set(args.query_id) queries = [q for q in queries if q["id"] in allowed] - routers = list(ROUTERS) if args.router == "both" else [args.router] + if args.use_agentic == "true": + routers = ["agent_explore"] + elif args.use_agentic == "false": + routers = ["classic"] + else: + routers = list(_MODES) timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") output_dir = Path(args.output_dir or f"/tmp/agentic_router_eval/{timestamp}") output_dir.mkdir(parents=True, exist_ok=True) @@ -289,6 +272,7 @@ async def main() -> None: query=item["query"], query_id=item["id"], router=router, + use_agentic=router != "classic", expected_keywords=item.get("expected_keywords") or [], ) all_runs.append(metrics) diff --git a/deploy/ecs/task-definition-api.staging.json b/deploy/ecs/task-definition-api.staging.json index 0b4af2c5..dde385e2 100644 --- a/deploy/ecs/task-definition-api.staging.json +++ b/deploy/ecs/task-definition-api.staging.json @@ -75,7 +75,8 @@ {"name": "LOGFIRE_TOKEN", "valueFrom": "${SECRETS_ARN}:LOGFIRE_TOKEN::"}, {"name": "QSTASH_TOKEN", "valueFrom": "${SECRETS_ARN}:QSTASH_TOKEN::"}, {"name": "QSTASH_CURRENT_SIGNING_KEY", "valueFrom": "${SECRETS_ARN}:QSTASH_CURRENT_SIGNING_KEY::"}, - {"name": "QSTASH_NEXT_SIGNING_KEY", "valueFrom": "${SECRETS_ARN}:QSTASH_NEXT_SIGNING_KEY::"} + {"name": "QSTASH_NEXT_SIGNING_KEY", "valueFrom": "${SECRETS_ARN}:QSTASH_NEXT_SIGNING_KEY::"}, + {"name": "CURSOR_API_KEY", "valueFrom": "${SECRETS_ARN}:CURSOR_API_KEY::"} ], "healthCheck": { "command": ["CMD-SHELL", "curl -f http://localhost:5005/health || exit 1"], diff --git a/deploy/ecs/task-definition-worker.staging.json b/deploy/ecs/task-definition-worker.staging.json index 202339d1..8f167696 100644 --- a/deploy/ecs/task-definition-worker.staging.json +++ b/deploy/ecs/task-definition-worker.staging.json @@ -81,7 +81,8 @@ {"name": "LOGFIRE_TOKEN", "valueFrom": "${SECRETS_ARN}:LOGFIRE_TOKEN::"}, {"name": "QSTASH_TOKEN", "valueFrom": "${SECRETS_ARN}:QSTASH_TOKEN::"}, {"name": "QSTASH_CURRENT_SIGNING_KEY", "valueFrom": "${SECRETS_ARN}:QSTASH_CURRENT_SIGNING_KEY::"}, - {"name": "QSTASH_NEXT_SIGNING_KEY", "valueFrom": "${SECRETS_ARN}:QSTASH_NEXT_SIGNING_KEY::"} + {"name": "QSTASH_NEXT_SIGNING_KEY", "valueFrom": "${SECRETS_ARN}:QSTASH_NEXT_SIGNING_KEY::"}, + {"name": "CURSOR_API_KEY", "valueFrom": "${SECRETS_ARN}:CURSOR_API_KEY::"} ], "healthCheck": { "command": ["CMD-SHELL", "python -c \"from shared.services.worker_health import assert_worker_healthy; assert_worker_healthy()\""], diff --git a/deprecated/mapnav/README.md b/deprecated/mapnav/README.md new file mode 100644 index 00000000..a7d0c19b --- /dev/null +++ b/deprecated/mapnav/README.md @@ -0,0 +1,26 @@ +# Archived map-nav retrieval route + +This directory holds the retired checklist map-nav episode (PLANNER / HARVEST / CONTROL). + +It is **not imported** by production code. Lint, typecheck, and pytest skip it. + +## Why it was archived + +Retrieval now has two live routes: + +- `use_agentic is False` → classic map-unit BM25 +- otherwise → `agent_explore` (default harness: `cursor_sdk`) + +The `RETRIEVAL_AGENTIC_ROUTER=mapnav` switch was removed. Setting that env var has no effect. + +Shared scoring used by publication and classic recall was extracted first, to `packages/shared-python/shared/services/retrieval/scoring/`. + +## How to restore (manual) + +1. Copy these files back to their original paths: + - `nav/` → `packages/shared-python/shared/services/retrieval/nav/` + - `nav_config.py`, `nav_snapshot.py`, `nav_bridge.py`, `nav_llm_backend.py` → `packages/shared-python/shared/services/retrieval/` + - `trace_mapnav.py` → `packages/shared-python/shared/services/retrieval/trace/mapnav.py` +2. Reverse the Phase 1 import moves: leftover map-nav modules expect `shared.services.retrieval.nav.*` for types that now live under `scoring/`. +3. Re-attach a third branch in `execution/routes.py` (`use_agentic is False` → classic, else map-nav or `agent_explore`). +4. Restore the archived tests from `tests/` and stop excluding this directory from pytest. diff --git a/packages/shared-python/shared/services/retrieval/nav/__init__.py b/deprecated/mapnav/nav/__init__.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/__init__.py rename to deprecated/mapnav/nav/__init__.py diff --git a/packages/shared-python/shared/services/retrieval/nav/_compat.py b/deprecated/mapnav/nav/_compat.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/_compat.py rename to deprecated/mapnav/nav/_compat.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_actions.py b/deprecated/mapnav/nav/nav_actions.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_actions.py rename to deprecated/mapnav/nav/nav_actions.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_address.py b/deprecated/mapnav/nav/nav_address.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_address.py rename to deprecated/mapnav/nav/nav_address.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_agent.py b/deprecated/mapnav/nav/nav_agent.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_agent.py rename to deprecated/mapnav/nav/nav_agent.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_assets.py b/deprecated/mapnav/nav/nav_assets.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_assets.py rename to deprecated/mapnav/nav/nav_assets.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_compose.py b/deprecated/mapnav/nav/nav_compose.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_compose.py rename to deprecated/mapnav/nav/nav_compose.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_control.py b/deprecated/mapnav/nav/nav_control.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_control.py rename to deprecated/mapnav/nav/nav_control.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_harvest.py b/deprecated/mapnav/nav/nav_harvest.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_harvest.py rename to deprecated/mapnav/nav/nav_harvest.py diff --git a/deprecated/mapnav/nav/nav_hierarchy.py b/deprecated/mapnav/nav/nav_hierarchy.py new file mode 100644 index 00000000..cabef82e --- /dev/null +++ b/deprecated/mapnav/nav/nav_hierarchy.py @@ -0,0 +1,111 @@ +"""In-memory hierarchy fixtures for map-nav tests. + +``ProviderToolSpace`` / ``NodeMeta`` / ``HierarchyProvider`` live in +``shared.services.retrieval.scoring.hierarchy``. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Dict, List, Optional, Sequence, Set, Tuple + +from shared.services.retrieval.scoring.hierarchy import NodeMeta + +@dataclass +class InMemoryNode: + section_id: str + title: str + content: str = "" + children: List[str] = field(default_factory=list) + + +class InMemoryHierarchyProvider: + """Minimal reference ``HierarchyProvider``: no scoring, no ToolSpace. + + Built directly from a ``{doc_id: [InMemoryNode, ...]}`` map plus a + ``{doc_id: [root_section_id, ...]}`` map — the "hierarchy + summary is + enough" claim's simplest possible witness. + """ + + def __init__( + self, + *, + roots_by_doc: Dict[str, Sequence[str]], + nodes: Dict[str, InMemoryNode], + summaries: Optional[Dict[str, str]] = None, + ) -> None: + self._roots_by_doc = {k: list(v) for k, v in roots_by_doc.items()} + self._nodes = dict(nodes) + self._summaries = dict(summaries or {}) + self._parent: Dict[str, str] = {} + for node in self._nodes.values(): + for child_id in node.children: + self._parent[child_id] = node.section_id + self._owner: Dict[str, str] = {} + for doc_id, root_ids in self._roots_by_doc.items(): + stack = list(root_ids) + while stack: + sid = stack.pop() + if sid in self._owner: + continue + self._owner[sid] = doc_id + node = self._nodes.get(sid) + if node: + stack.extend(node.children) + + def owner_document(self, node_id: str) -> Optional[str]: + return self._owner.get(str(node_id or "").strip()) + + def roots(self, doc_id: str) -> Sequence[str]: + return list(self._roots_by_doc.get(doc_id, ())) + + def children(self, section_id: str) -> Sequence[str]: + node = self._nodes.get(section_id) + return list(node.children) if node else [] + + def node_meta(self, section_id: str) -> NodeMeta: + node = self._nodes.get(section_id) + if node is None: + return NodeMeta() + return NodeMeta( + title=node.title, + summary=self._summaries.get(section_id, ""), + has_children=bool(node.children), + ) + + def parent_id(self, section_id: str) -> Optional[str]: + return self._parent.get(section_id) + + def relations(self, section_id: str) -> Tuple[Set[str], Set[str]]: + ancestors: Set[str] = set() + cur = self._parent.get(section_id) + while cur: + ancestors.add(cur) + cur = self._parent.get(cur) + descendants: Set[str] = set() + stack = list(self.children(section_id)) + while stack: + cid = stack.pop() + if cid in descendants: + continue + descendants.add(cid) + stack.extend(self.children(cid)) + return ancestors, descendants + + def content(self, section_id: str) -> str: + node = self._nodes.get(section_id) + if node is None: + return "" + parts: List[str] = [] + + def walk(sid: str) -> None: + cur = self._nodes.get(sid) + if cur is None: + return + if cur.content: + parts.append(cur.content) + for cid in cur.children: + walk(cid) + + walk(section_id) + return "\n".join(parts) diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_knowhere.py b/deprecated/mapnav/nav/nav_knowhere.py similarity index 73% rename from packages/shared-python/shared/services/retrieval/nav/nav_knowhere.py rename to deprecated/mapnav/nav/nav_knowhere.py index bacce7f0..90d5cf3d 100644 --- a/packages/shared-python/shared/services/retrieval/nav/nav_knowhere.py +++ b/deprecated/mapnav/nav/nav_knowhere.py @@ -1,21 +1,8 @@ -"""Knowhere-native hierarchy provider for MAP-NAV. +"""Knowhere-native hierarchy provider leftovers for MAP-NAV. -Knowhere stores everything MAP-NAV needs in two tables: - -``document_sections`` - ``section_id`` (PK) / ``parent_section_id`` (self FK) / ``section_path`` / - ``section_title`` / ``section_level`` / ``summary`` / ``sort_order`` -``document_chunks`` - ``chunk_id`` / ``section_id`` (FK) / ``chunk_type`` / ``content`` / - ``chunk_metadata`` / ``sort_order`` - -``SectionRow`` / ``UnitRow`` mirror those shapes. ``KnowhereProvider`` is a -synchronous in-memory snapshot (so the nav kernel stays sync inside knowhere's -async path). Load from the production Postgres schema via -``load_document_from_db`` / ``load_namespace_from_db`` (local Docker or prod). - -Hierarchy comes from ``parent_section_id`` and depth from ``section_level``, -not from parsing ``section_id`` or ``section_path`` separators. +Publication types and the eager ``KnowhereProvider`` live in +``shared.services.retrieval.scoring``. This module keeps the episode-local +lazy/DB loaders used by map-nav snapshot loading. """ from __future__ import annotations @@ -23,11 +10,9 @@ import os import logging import time -from dataclasses import dataclass, field from hashlib import sha256 from typing import ( Any, - Callable, Dict, Iterable, List, @@ -39,89 +24,25 @@ Tuple, ) -from .nav_address import NavLevel -from .nav_hierarchy import NodeMeta -from .knowhere_hybrid import ( +from shared.services.retrieval.nav.nav_address import NavLevel +from shared.services.retrieval.scoring.hierarchy import NodeMeta +from shared.services.retrieval.scoring.knowhere_hybrid import ( MAP_UNIT_INDEX_FORMAT_VERSION, PersistedScoreCorpus, PersistedScoreUnit, tokenize_query_for_ranker, ) +from shared.services.retrieval.scoring.knowhere_provider import ( + KnowhereProvider, + SectionRow, + UnitRow, + is_root_section_path, +) -_ASSET_TYPES = ("table", "image") -# Body chunk types that can own a Root-parked asset via connect_to. Both -# chunk-track ("text") and page-track ("page") body chunks can embed assets. -_BODY_CHUNK_TYPES = ("text", "page") -# Knowhere sentinel path for the virtual document container (not a collectable leaf). -ROOT_SECTION_PATH = "Root" _DEFAULT_DSN = "postgresql://root:root123@127.0.0.1:5433/Knowhere" _MAP_SCORE_CHANNELS: Tuple[str, str] = ("path", "content") _logger = logging.getLogger(__name__) - -@dataclass(frozen=True) -class SectionRow: - """One ``document_sections`` row.""" - - section_id: str - parent_section_id: Optional[str] - section_path: str - section_title: str - section_level: int - summary: str - sort_order: int - - -@dataclass(frozen=True) -class UnitRow: - """One ``document_chunks`` row.""" - - chunk_id: str - section_id: Optional[str] - chunk_type: str - content: str - sort_order: int - source_chunk_path: str = "" - file_path: str = "" - metadata: Dict[str, Any] = field(default_factory=dict) - - -def asset_display_text(unit: UnitRow) -> str: - """Body text for an asset unit, whose ``content`` is only a file path. - - Mirrors knowhere's own assembly: an asset contributes its summary, not its - path. Without this an asset unit is unscorable and unreadable. - """ - meta = unit.metadata or {} - title = str(meta.get("asset_title") or "").strip() - summary = str(meta.get("summary") or "").strip() - ref = unit.file_path or unit.source_chunk_path or unit.content - label = "Table" if unit.chunk_type == "table" else "Image" - parts = [f"[{label}: {ref}]"] if ref else [f"[{label}]"] - if title: - parts.append(title) - if summary: - parts.append(summary) - return "\n".join(parts) - - -def normalize_section_path(path: str) -> str: - """Canonical path for gold/lookup: ``a / b`` (accepts ``a/b`` or ``a / b``).""" - raw = str(path or "").strip().strip("/") - if not raw or raw == ROOT_SECTION_PATH: - return "" - if " / " in raw: - parts = [p.strip() for p in raw.split(" / ") if p.strip()] - else: - parts = [p.strip() for p in raw.split("/") if p.strip()] - return " / ".join(parts) - - -def is_root_section_path(path: str) -> bool: - """True when the raw ``section_path`` is Knowhere's Root container.""" - return str(path or "").strip() == ROOT_SECTION_PATH - - def is_root_section(provider_or_ts: Any, section_id: str) -> bool: """True when ``section_id`` is a Root container (raw path, not normalized).""" sid = str(section_id or "").strip() @@ -137,21 +58,6 @@ def is_root_section(provider_or_ts: Any, section_id: str) -> bool: return False -def _connect_to_targets(metadata: Dict[str, Any]) -> List[str]: - """``chunk_metadata.connect_to[].target`` ids (document order, first wins upstream).""" - raw = metadata.get("connect_to") if isinstance(metadata, dict) else None - if not isinstance(raw, list): - return [] - out: List[str] = [] - for conn in raw: - if not isinstance(conn, dict): - continue - target = str(conn.get("target") or "").strip() - if target: - out.append(target) - return out - - def knowhere_database_url() -> str: configured = ( str(os.environ.get("KNOWHERE_DATABASE_URL") or "").strip() @@ -303,7 +209,7 @@ def load_persisted_score_corpus( ``document_map_unit_tokens`` filtered to the query tokens. Average IDF comes from ``document_map_unit_indexes`` (written at index time). """ - from shared.services.retrieval.nav.persisted_score_load import ( + from shared.services.retrieval.scoring.persisted_score_load import ( build_channel_bm25_stats, combine_average_idf, ) @@ -649,252 +555,6 @@ def _unit_from_row(row: Sequence[object]) -> UnitRow: ) -class KnowhereProvider: - """``HierarchyProvider`` over knowhere section/chunk rows.""" - - def __init__( - self, - *, - doc_id: str, - sections: Sequence[SectionRow], - units: Sequence[UnitRow], - lazy_loader: Optional[Callable[[str], Sequence[UnitRow]]] = None, - known_chunk_ids: Optional[Sequence[str]] = None, - ) -> None: - self.doc_id = str(doc_id) - self._lazy_loader = lazy_loader - self._loaded_sections: Set[str] = set() - self._sections: Dict[str, SectionRow] = {s.section_id: s for s in sections} - self._children: Dict[str, List[str]] = {} - self._roots: List[str] = [] - self._path_to_id: Dict[str, str] = {} - for row in sorted(sections, key=lambda s: (s.sort_order, s.section_id)): - parent = row.parent_section_id - if parent and parent in self._sections: - self._children.setdefault(parent, []).append(row.section_id) - else: - self._roots.append(row.section_id) - key = normalize_section_path(row.section_path) - if key: - self._path_to_id[key] = row.section_id - - self._units_by_section: Dict[str, List[UnitRow]] = {} - self._chunk_ids: Set[str] = set() - if known_chunk_ids: - self._chunk_ids.update( - str(chunk_id).strip() - for chunk_id in known_chunk_ids - if str(chunk_id).strip() - ) - for unit in sorted(units, key=lambda u: (u.sort_order, u.chunk_id)): - sid = unit.section_id - if not sid or sid not in self._sections: - continue - self._units_by_section.setdefault(sid, []).append(unit) - if unit.chunk_id: - self._chunk_ids.add(unit.chunk_id) - self._remount_root_assets() - - def _ensure_section_loaded(self, section_id: str) -> None: - if self._lazy_loader is None or section_id in self._loaded_sections: - return - loaded = list(self._lazy_loader(section_id) or ()) - self._loaded_sections.add(section_id) - if not loaded: - return - current = self._units_by_section.setdefault(section_id, []) - known = {unit.chunk_id for unit in current} - for unit in loaded: - if unit.chunk_id and unit.chunk_id not in known: - current.append(unit) - known.add(unit.chunk_id) - current.sort(key=lambda unit: (unit.sort_order, unit.chunk_id)) - - def _remount_root_assets(self) -> None: - """Reattach Root-FK image|table units to host sections via ``connect_to``. - - Aligns with Knowhere ``resolve_root_asset_owners``: assets whose FK still - points at Root are owned by the text chunk that lists them in - ``metadata.connect_to``. Unresolved Root assets leave the evidence surface. - """ - root_sids = [ - sid - for sid, row in self._sections.items() - if is_root_section_path(row.section_path) - ] - if not root_sids: - return - - root_assets: Dict[str, UnitRow] = {} - for sid in root_sids: - for unit in self._units_by_section.get(sid, ()): - if unit.chunk_type in _ASSET_TYPES and unit.chunk_id: - root_assets[unit.chunk_id] = unit - if not root_assets: - return - - owner_by_asset: Dict[str, str] = {} - for sid, units in self._units_by_section.items(): - row = self._sections.get(sid) - if row is None or is_root_section_path(row.section_path): - continue - for unit in units: - if unit.chunk_type not in _BODY_CHUNK_TYPES: - continue - for target in _connect_to_targets(unit.metadata or {}): - if target in root_assets and target not in owner_by_asset: - owner_by_asset[target] = sid - - touched_owners: Set[str] = set() - for chunk_id, owner_sid in owner_by_asset.items(): - unit = root_assets[chunk_id] - remounted = UnitRow( - chunk_id=unit.chunk_id, - section_id=owner_sid, - chunk_type=unit.chunk_type, - content=unit.content, - sort_order=unit.sort_order, - source_chunk_path=unit.source_chunk_path, - file_path=unit.file_path, - metadata=dict(unit.metadata or {}), - ) - self._units_by_section.setdefault(owner_sid, []).append(remounted) - touched_owners.add(owner_sid) - - for sid in root_sids: - self._units_by_section[sid] = [ - u - for u in self._units_by_section.get(sid, ()) - if u.chunk_type not in _ASSET_TYPES - ] - for sid in touched_owners: - self._units_by_section[sid].sort(key=lambda u: (u.sort_order, u.chunk_id)) - - def address_level(self, node_id: str) -> Optional[NavLevel]: - sid = str(node_id or "").strip() - if not sid: - return NavLevel.NAMESPACE - if sid == self.doc_id: - return NavLevel.DOCUMENT - if sid in self._sections: - return NavLevel.SECTION - if sid in self._chunk_ids: - return NavLevel.CHUNK - return None - - def owner_document(self, node_id: str) -> Optional[str]: - sid = str(node_id or "").strip() - if not sid: - return None - if sid == self.doc_id or sid in self._sections or sid in self._chunk_ids: - return self.doc_id - return None - - def roots(self, doc_id: str) -> Sequence[str]: - return list(self._roots) if str(doc_id) == self.doc_id else [] - - def children(self, section_id: str) -> Sequence[str]: - return list(self._children.get(section_id, ())) - - def node_meta(self, section_id: str) -> NodeMeta: - row = self._sections.get(section_id) - if row is None: - return NodeMeta() - return NodeMeta( - title=row.section_title, - summary=row.summary, - has_children=bool(self._children.get(section_id)), - ) - - def relations(self, section_id: str) -> Tuple[Set[str], Set[str]]: - ancestors: Set[str] = set() - cur = self._sections.get(section_id) - while cur is not None and cur.parent_section_id: - parent = cur.parent_section_id - if parent in ancestors: - break - ancestors.add(parent) - cur = self._sections.get(parent) - descendants: Set[str] = set() - stack = list(self.children(section_id)) - while stack: - cid = stack.pop() - if cid in descendants: - continue - descendants.add(cid) - stack.extend(self.children(cid)) - return ancestors, descendants - - def content(self, section_id: str) -> str: - units = self.subtree_units(section_id) - return "\n".join(self.unit_text(u) for u in units if self.unit_text(u)) - - def self_units(self, section_id: str) -> List[UnitRow]: - self._ensure_section_loaded(section_id) - return list(self._units_by_section.get(section_id, ())) - - def subtree_units(self, section_id: str) -> List[UnitRow]: - out = list(self.self_units(section_id)) - for cid in self.relations(section_id)[1]: - out.extend(self.self_units(cid)) - out.sort(key=lambda u: (u.sort_order, u.chunk_id)) - return out - - def leaf_ids(self, section_id: str) -> List[str]: - out: List[str] = [] - - def rec(sid: str) -> None: - kids = self.children(sid) - if not kids: - out.append(sid) - return - for kid in kids: - rec(kid) - - rec(section_id) - return out - - def path_titles(self, section_id: str) -> str: - chain: List[str] = [] - cur = self._sections.get(section_id) - while cur is not None: - if cur.section_title: - chain.append(cur.section_title) - parent = cur.parent_section_id - cur = self._sections.get(parent) if parent else None - return " / ".join(reversed(chain)) - - def parent_id(self, section_id: str) -> Optional[str]: - row = self._sections.get(section_id) - return row.parent_section_id if row else None - - def section_path(self, section_id: str) -> str: - row = self._sections.get(section_id) - return str(row.section_path or "") if row else "" - - def resolve_path(self, path: str) -> Optional[str]: - """Map a human/gold path to ``section_id`` (``sec_*``).""" - key = normalize_section_path(path) - if not key: - return None - return self._path_to_id.get(key) - - def unit_text(self, unit: UnitRow) -> str: - if unit.chunk_type in _ASSET_TYPES: - return asset_display_text(unit) - return str(unit.content or "").strip() - - def summaries(self) -> Dict[str, str]: - return { - sid: row.summary - for sid, row in self._sections.items() - if str(row.summary or "").strip() - } - - def all_section_ids(self) -> List[str]: - return list(self._sections) - - class LazyKnowhereProvider(KnowhereProvider): """Hierarchy provider that loads full chunk rows only on first access.""" diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_llm.py b/deprecated/mapnav/nav/nav_llm.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_llm.py rename to deprecated/mapnav/nav/nav_llm.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_map_scores.py b/deprecated/mapnav/nav/nav_map_scores.py similarity index 52% rename from packages/shared-python/shared/services/retrieval/nav/nav_map_scores.py rename to deprecated/mapnav/nav/nav_map_scores.py index 35ffd890..8877451a 100644 --- a/packages/shared-python/shared/services/retrieval/nav/nav_map_scores.py +++ b/deprecated/mapnav/nav/nav_map_scores.py @@ -4,18 +4,8 @@ import time from typing import Any, Dict, List, Optional, Sequence, Set, Tuple -from .knowhere_hybrid import ( - build_content_search_text, - build_path_search_text, - build_term_search_text, - PersistedScoreCorpus, - PersistedScoreUnit, - score_persisted_corpus_many, -) -from .persisted_score_load import ( - average_idf_from_unit_dfs, - build_channel_bm25_stats, -) +from shared.services.retrieval.scoring.knowhere_hybrid import score_persisted_corpus_many +from shared.services.retrieval.scoring.score_units import _walk_tree _logger = logging.getLogger(__name__) @@ -35,188 +25,6 @@ def _count_tree_shape( leaf_sections: int = sum(len(value[1]) for value in tree_by_doc.values()) return section_nodes, section_edges, leaf_sections - -def _build_legacy_score_corpus(ts: Any, doc_ids: Sequence[str]) -> PersistedScoreCorpus: - """Build the retired in-memory scorer input when persisted indexes are absent.""" - raw_units: List[dict] = [] - for doc_id in doc_ids: - raw_units.extend(build_score_units(ts, doc_id)) - frequencies: Dict[Tuple[str, str], Dict[str, int]] = {} - unit_rows: List[dict] = [] - path_dfs: Dict[str, int] = {} - content_dfs: Dict[str, int] = {} - for unit in raw_units: - unit_id = str(unit.get("chunk_id") or "").strip() - if not unit_id: - continue - path_tokens = str(unit.get("path_search_text") or "").split() - content_tokens = str(unit.get("content_search_text") or "").split() - path_freq: Dict[str, int] = {} - content_freq: Dict[str, int] = {} - for token in path_tokens: - path_freq[token] = path_freq.get(token, 0) + 1 - for token in content_tokens: - content_freq[token] = content_freq.get(token, 0) + 1 - frequencies[(unit_id, "path")] = path_freq - frequencies[(unit_id, "content")] = content_freq - for token in path_freq: - path_dfs[token] = path_dfs.get(token, 0) + 1 - for token in content_freq: - content_dfs[token] = content_dfs.get(token, 0) + 1 - unit_rows.append( - { - "unit_id": unit_id, - "path_length": len(path_tokens), - "content_length": len(content_tokens), - } - ) - unit_count = len(unit_rows) - return PersistedScoreCorpus( - units=[ - PersistedScoreUnit( - unit_id=str(row["unit_id"]), - path_length=int(row["path_length"]), - content_length=int(row["content_length"]), - path_frequencies=frequencies[(str(row["unit_id"]), "path")], - content_frequencies=frequencies[(str(row["unit_id"]), "content")], - ) - for row in unit_rows - ], - path_stats=build_channel_bm25_stats( - unit_rows=unit_rows, - map_unit_id_field="unit_id", - length_field="path_length", - channel="path", - query_tokens=list(path_dfs), - frequencies=frequencies, - average_idf=average_idf_from_unit_dfs( - unit_count=unit_count, token_document_frequency=path_dfs - ), - ), - content_stats=build_channel_bm25_stats( - unit_rows=unit_rows, - map_unit_id_field="unit_id", - length_field="content_length", - channel="content", - query_tokens=list(content_dfs), - frequencies=frequencies, - average_idf=average_idf_from_unit_dfs( - unit_count=unit_count, token_document_frequency=content_dfs - ), - ), - ) - - -def _children_ids(ts: Any, section_id: str, doc_id: str) -> List[str]: - children_fn = getattr(ts, "_children_for_section_path", None) - if not callable(children_fn): - st = ts.get_structure(section_id) - rows = st.get("children") or [] - return [ - str(r.get("section_id") or "").strip() for r in rows if r.get("section_id") - ] - rows = children_fn(section_id, doc_id) - return [str(r.get("section_id") or "").strip() for r in rows if r.get("section_id")] - - -def _line_content(ts: Any, section_id: str, doc_id: str) -> str: - """Raw line text for a section node (no truncation).""" - idx = getattr(ts, "_idx", None) - b = getattr(idx, "_bundles", {}).get(doc_id) if idx is not None else None - if b is None: - path_fn = getattr(ts, "path_titles", None) - if callable(path_fn): - path = str(path_fn(section_id, doc_id) or "").strip() - return path.rsplit(" / ", 1)[-1] if path else "" - st = ts.get_structure(section_id) - return str(st.get("preview") or "").strip() - loc = getattr(idx, "_node_to_doc_line", {}).get(section_id) - if not loc: - return "" - _doc, line_idx = loc - if line_idx < 0 or line_idx >= len(b.lines): - return "" - return str(b.lines[line_idx].content or "").strip() - - -def _ancestor_path_titles(ts: Any, section_id: str, doc_id: str) -> str: - idx = getattr(ts, "_idx", None) - if idx is None: - # Provider-backed spaces expose the title chain directly; without this - # the path channel would score every unit as empty. - path_fn = getattr(ts, "path_titles", None) - return str(path_fn(section_id, doc_id) or "") if callable(path_fn) else "" - try: - ancestors = list(idx.ancestor_line_node_ids(section_id)) - except Exception: - ancestors = [] - titles: List[str] = [] - for aid in reversed(ancestors): - if not str(aid).startswith(f"{doc_id}:"): - continue - titles.append(_line_content(ts, aid, doc_id)) - titles.append(_line_content(ts, section_id, doc_id)) - return " / ".join(t for t in titles if t) - - -def _self_only_text(ts: Any, section_id: str, doc_id: str) -> Tuple[str, bool]: - """Return (self_text, has_interstitial_body). - - Interstitial means self_only span contains content beyond the heading line - itself (structural: more than one line/chunk in the self span). - """ - self_fn = getattr(ts, "materialize_self_only_chunks", None) - if not callable(self_fn): - return "", False - chunks = list(self_fn(section_id, doc_id) or []) - if not chunks: - return "", False - texts = [str(getattr(c, "text", "") or "").strip() for c in chunks] - texts = [t for t in texts if t] - if not texts: - return "", False - # Structural interstitial: self span covers more than the node heading line. - has_interstitial = len(chunks) > 1 - return "\n".join(texts), has_interstitial - - -def _section_body_text(ts: Any, section_id: str, doc_id: str) -> str: - """Heading + lines until first structural child (leaf body / parent self span).""" - text, _ = _self_only_text(ts, section_id, doc_id) - if text: - return text - return _line_content(ts, section_id, doc_id) - - -def _walk_tree( - ts: Any, - doc_id: str, - root_ids: Sequence[str], -) -> Tuple[Dict[str, List[str]], Set[str], Dict[str, str]]: - """Return children map, leaf ids, and title map for reachable nodes.""" - children_map: Dict[str, List[str]] = {} - titles: Dict[str, str] = {} - leaves: Set[str] = set() - seen: Set[str] = set() - - def walk(sid: str) -> None: - if not sid or sid in seen: - return - seen.add(sid) - titles[sid] = _line_content(ts, sid, doc_id) - kids = [c for c in _children_ids(ts, sid, doc_id) if c] - children_map[sid] = kids - if not kids: - leaves.add(sid) - return - for kid in kids: - walk(kid) - - for rid in root_ids: - walk(rid) - return children_map, leaves, titles - - def _collect_descendant_leaves( section_id: str, children_map: Dict[str, List[str]], @@ -271,74 +79,6 @@ def _pool_unit_scores_to_tree( return map_scores -def build_score_units( - ts: Any, doc_id: str, root_ids: Optional[Sequence[str]] = None -) -> List[dict]: - """Build leaf (+ interstitial self_only) units for hybrid scoring.""" - if root_ids is None: - root_ids = list(ts.sections_for_doc(doc_id)) - children_map, leaves, titles = _walk_tree(ts, doc_id, root_ids) - units: List[dict] = [] - seen_unit_ids: Set[str] = set() - - for leaf_id in sorted(leaves): - content = _section_body_text(ts, leaf_id, doc_id) or ( - titles.get(leaf_id) or _line_content(ts, leaf_id, doc_id) - ) - path_text = _ancestor_path_titles(ts, leaf_id, doc_id) - unit_id = leaf_id - if unit_id in seen_unit_ids: - continue - seen_unit_ids.add(unit_id) - title = titles.get(leaf_id) or _line_content(ts, leaf_id, doc_id) - units.append( - { - "chunk_id": unit_id, - "section_id": leaf_id, - "kind": "leaf", - "content": content, - "path_text": path_text, - "path_search_text": build_path_search_text( - section_path=path_text, section_title=title or content - ), - "content_search_text": build_content_search_text(content), - "term_search_text": build_term_search_text( - content, path_text=path_text - ), - } - ) - - # Parents with interstitial self body. - for sid, kids in children_map.items(): - if not kids: - continue - self_text, has_interstitial = _self_only_text(ts, sid, doc_id) - if not has_interstitial or not self_text: - continue - unit_id = f"{sid}__self" - if unit_id in seen_unit_ids: - continue - seen_unit_ids.add(unit_id) - path_text = _ancestor_path_titles(ts, sid, doc_id) - units.append( - { - "chunk_id": unit_id, - "section_id": sid, - "kind": "self_only", - "content": self_text, - "path_text": path_text, - "path_search_text": build_path_search_text( - section_path=path_text, section_title=titles.get(sid) or "" - ), - "content_search_text": build_content_search_text(self_text), - "term_search_text": build_term_search_text( - self_text, path_text=path_text - ), - } - ) - return units - - def compute_map_scores( ts: Any, *, @@ -453,13 +193,6 @@ def compute_corpus_map_and_unit_scores_many( time.perf_counter() - loader_started, persisted_corpus is not None, ) - if persisted_corpus is None: - _logger.warning( - "retrieval map index unavailable; using bounded legacy in-memory scorer " - "documents=%d", - len(valid_doc_ids), - ) - persisted_corpus = _build_legacy_score_corpus(ts, valid_doc_ids) score_started = time.perf_counter() unit_scores_by_query = ( score_persisted_corpus_many(persisted_corpus, unique_queries) diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_navigate.py b/deprecated/mapnav/nav/nav_navigate.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_navigate.py rename to deprecated/mapnav/nav/nav_navigate.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_node_filter.py b/deprecated/mapnav/nav/nav_node_filter.py similarity index 70% rename from packages/shared-python/shared/services/retrieval/nav/nav_node_filter.py rename to deprecated/mapnav/nav/nav_node_filter.py index 45b2c1eb..5e895ee2 100644 --- a/packages/shared-python/shared/services/retrieval/nav/nav_node_filter.py +++ b/deprecated/mapnav/nav/nav_node_filter.py @@ -7,21 +7,14 @@ from __future__ import annotations -import re from dataclasses import dataclass, field -from typing import Any, Dict, Iterable, List, Literal, Sequence, Tuple +from typing import Any, Dict, Iterable, List, Sequence, Tuple -MatchKind = Literal["substring", "regex"] -FilterField = Literal["path", "summary"] - -_MAX_REGEX_PATTERN_LEN = 256 - - -@dataclass(frozen=True) -class FieldPredicate: - field: FilterField - terms: Tuple[str, ...] - match: MatchKind = "substring" +from shared.services.retrieval.scoring.node_filter_predicates import ( + FieldPredicate, + _compile_predicates, + _node_matches, +) @dataclass(frozen=True) @@ -36,26 +29,9 @@ class FilterResult: cardinality: int failed_predicates: List[str] = field(default_factory=list) - -def field_predicate( - field: str, - terms: Sequence[str], - match: str = "substring", -) -> FieldPredicate: - key = str(field or "").strip().lower() - if key not in {"path", "summary"}: - raise ValueError(f"unsupported filter field: {field!r}") - kind = str(match or "substring").strip().lower() - if kind not in {"substring", "regex"}: - raise ValueError(f"unsupported filter match: {match!r}") - cleaned = tuple(str(term) for term in terms if str(term)) - return FieldPredicate(field=key, terms=cleaned, match=kind) # type: ignore[arg-type] - - def node_filter(predicates: Sequence[FieldPredicate]) -> NodeFilter: return NodeFilter(predicates=tuple(predicates)) - def apply_node_filter( ts: Any, doc_ids: Sequence[str], @@ -133,52 +109,6 @@ def render_submap_observation( lines.append("\n".join(block)) return "\n".join(lines) - -def _compile_predicates( - predicates: Sequence[FieldPredicate], -) -> Tuple[List[Tuple[FieldPredicate, List[Any]]], List[str]]: - compiled: List[Tuple[FieldPredicate, List[Any]]] = [] - failed: List[str] = [] - for pred in predicates: - if pred.match != "regex": - compiled.append((pred, [])) - continue - patterns: List[Any] = [] - ok = True - for term in pred.terms: - if len(term) > _MAX_REGEX_PATTERN_LEN: - failed.append(f"{pred.field}:regex:too_long") - ok = False - break - try: - patterns.append(re.compile(term, flags=re.IGNORECASE)) - except re.error: - failed.append(f"{pred.field}:regex:invalid") - ok = False - break - if ok: - compiled.append((pred, patterns)) - return compiled, failed - - -def _node_matches( - values: Dict[str, str], - compiled: Sequence[Tuple[FieldPredicate, List[Any]]], -) -> bool: - if not compiled: - return True - for pred, patterns in compiled: - text = values.get(pred.field, "") - if pred.match == "regex": - if not patterns or not any(p.search(text or "") for p in patterns): - return False - continue - haystack = (text or "").lower() - if not pred.terms or not any(term.lower() in haystack for term in pred.terms): - return False - return True - - def _iter_doc_nodes(ts: Any, doc_id: str) -> Iterable[Tuple[str, str, bool]]: yield doc_id, doc_id, True stack = list(_roots(ts, doc_id)) diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_orchestrate.py b/deprecated/mapnav/nav/nav_orchestrate.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_orchestrate.py rename to deprecated/mapnav/nav/nav_orchestrate.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_plan.py b/deprecated/mapnav/nav/nav_plan.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_plan.py rename to deprecated/mapnav/nav/nav_plan.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_policy.py b/deprecated/mapnav/nav/nav_policy.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_policy.py rename to deprecated/mapnav/nav/nav_policy.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_projection.py b/deprecated/mapnav/nav/nav_projection.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_projection.py rename to deprecated/mapnav/nav/nav_projection.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_scope_filter.py b/deprecated/mapnav/nav/nav_scope_filter.py similarity index 99% rename from packages/shared-python/shared/services/retrieval/nav/nav_scope_filter.py rename to deprecated/mapnav/nav/nav_scope_filter.py index 886a0527..a381a9a8 100644 --- a/packages/shared-python/shared/services/retrieval/nav/nav_scope_filter.py +++ b/deprecated/mapnav/nav/nav_scope_filter.py @@ -11,11 +11,12 @@ from dataclasses import dataclass, field from typing import Any, Dict, List, Literal, Optional, Sequence +from shared.services.retrieval.scoring.node_filter_predicates import field_predicate + from .nav_node_filter import ( FilterResult, NodeFilter, apply_node_filter, - field_predicate, node_filter, render_submap_observation, ) diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_token_budget.py b/deprecated/mapnav/nav/nav_token_budget.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_token_budget.py rename to deprecated/mapnav/nav/nav_token_budget.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_types.py b/deprecated/mapnav/nav/nav_types.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_types.py rename to deprecated/mapnav/nav/nav_types.py diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_verify.py b/deprecated/mapnav/nav/nav_verify.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav/nav_verify.py rename to deprecated/mapnav/nav/nav_verify.py diff --git a/packages/shared-python/shared/services/retrieval/nav_bridge.py b/deprecated/mapnav/nav_bridge.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav_bridge.py rename to deprecated/mapnav/nav_bridge.py diff --git a/packages/shared-python/shared/services/retrieval/nav_config.py b/deprecated/mapnav/nav_config.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav_config.py rename to deprecated/mapnav/nav_config.py diff --git a/packages/shared-python/shared/services/retrieval/nav_llm_backend.py b/deprecated/mapnav/nav_llm_backend.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/nav_llm_backend.py rename to deprecated/mapnav/nav_llm_backend.py diff --git a/packages/shared-python/shared/services/retrieval/nav_snapshot.py b/deprecated/mapnav/nav_snapshot.py similarity index 99% rename from packages/shared-python/shared/services/retrieval/nav_snapshot.py rename to deprecated/mapnav/nav_snapshot.py index 9f92617c..5e1016dd 100644 --- a/packages/shared-python/shared/services/retrieval/nav_snapshot.py +++ b/deprecated/mapnav/nav_snapshot.py @@ -41,12 +41,14 @@ from shared.models.database.job_result import JobResult from shared.services.retrieval.nav.nav_knowhere import ( LazyKnowhereProvider, - KnowhereProvider, NamespaceKnowhereProvider, ReadOnlyChunkStore, + knowhere_database_url, +) +from shared.services.retrieval.scoring.knowhere_provider import ( + KnowhereProvider, SectionRow, UnitRow, - knowhere_database_url, ) from shared.services.retrieval.search.section_filters import is_excluded_section from shared.services.retrieval.serving_manifest import ( diff --git a/apps/api/tests/contract/test_retrieval_lazy_snapshot_quality_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_lazy_snapshot_quality_contract.py similarity index 97% rename from apps/api/tests/contract/test_retrieval_lazy_snapshot_quality_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_lazy_snapshot_quality_contract.py index c796e2a1..00855e6b 100644 --- a/apps/api/tests/contract/test_retrieval_lazy_snapshot_quality_contract.py +++ b/deprecated/mapnav/tests/api-contract/test_retrieval_lazy_snapshot_quality_contract.py @@ -6,26 +6,28 @@ import math from typing import Any -from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace from shared.services.retrieval.nav.nav_knowhere import ( - KnowhereProvider, LazyKnowhereProvider, NamespaceKnowhereProvider, - SectionRow, - UnitRow, knowhere_database_url, ) from shared.services.retrieval.nav.nav_map_scores import ( - build_score_units, compute_corpus_map_and_unit_scores, compute_corpus_map_and_unit_scores_many, ) -from shared.services.retrieval.nav.knowhere_hybrid import ( +from shared.services.retrieval.scoring.hierarchy import ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_hybrid import ( PersistedBm25Stats, PersistedScoreCorpus, PersistedScoreUnit, score_persisted_corpus_many, ) +from shared.services.retrieval.scoring.knowhere_provider import ( + KnowhereProvider, + SectionRow, + UnitRow, +) +from shared.services.retrieval.scoring.score_units import build_score_units @dataclass diff --git a/apps/api/tests/contract/test_retrieval_lazy_tree_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_lazy_tree_contract.py similarity index 93% rename from apps/api/tests/contract/test_retrieval_lazy_tree_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_lazy_tree_contract.py index 9571f151..038756a9 100644 --- a/apps/api/tests/contract/test_retrieval_lazy_tree_contract.py +++ b/deprecated/mapnav/tests/api-contract/test_retrieval_lazy_tree_contract.py @@ -2,9 +2,9 @@ from __future__ import annotations -from shared.services.retrieval.nav.nav_hierarchy import NodeMeta, ProviderToolSpace -from shared.services.retrieval.nav.nav_knowhere import KnowhereProvider, SectionRow -from shared.services.retrieval.nav.nav_map_scores import _walk_tree +from shared.services.retrieval.scoring.hierarchy import NodeMeta, ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_provider import KnowhereProvider, SectionRow +from shared.services.retrieval.scoring.score_units import _walk_tree from shared.services.retrieval.nav._compat import Chunk from shared.services.retrieval.nav.nav_compose import pack_nav_evidence from shared.services.retrieval.nav.nav_types import NavConfig, NavState diff --git a/apps/api/tests/contract/test_retrieval_map_score_parity_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_map_score_parity_contract.py similarity index 100% rename from apps/api/tests/contract/test_retrieval_map_score_parity_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_map_score_parity_contract.py diff --git a/apps/api/tests/contract/test_retrieval_map_unit_index_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_map_unit_index_contract.py similarity index 99% rename from apps/api/tests/contract/test_retrieval_map_unit_index_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_map_unit_index_contract.py index 5128382f..9cde1b65 100644 --- a/apps/api/tests/contract/test_retrieval_map_unit_index_contract.py +++ b/deprecated/mapnav/tests/api-contract/test_retrieval_map_unit_index_contract.py @@ -13,23 +13,25 @@ DocumentMapUnitIndex, DocumentMapUnitToken, ) -from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace from shared.services.retrieval.nav._compat import Chunk, EpisodeResult from shared.services.retrieval.nav import nav_knowhere +from shared.services.retrieval.nav.nav_knowhere import ( + LazyKnowhereProvider, + NamespaceKnowhereProvider, + ReadOnlyChunkStore, +) from shared.services.retrieval.nav.nav_map_scores import ( - build_score_units, compute_corpus_map_and_unit_scores, select_map_highlights, ) from shared.services.retrieval.hydration.connected import hydrate_connected_target_rows -from shared.services.retrieval.nav.nav_knowhere import ( +from shared.services.retrieval.scoring.hierarchy import ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_provider import ( KnowhereProvider, - LazyKnowhereProvider, - NamespaceKnowhereProvider, - ReadOnlyChunkStore, SectionRow, UnitRow, ) +from shared.services.retrieval.scoring.score_units import build_score_units from shared.services.retrieval.nav_snapshot import load_nav_snapshot from shared.services.retrieval.publication_content import ( replace_document_revision_content, diff --git a/apps/api/tests/contract/test_retrieval_mapnav_session_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_mapnav_session_contract.py similarity index 98% rename from apps/api/tests/contract/test_retrieval_mapnav_session_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_mapnav_session_contract.py index d267941b..f5ca83f6 100644 --- a/apps/api/tests/contract/test_retrieval_mapnav_session_contract.py +++ b/deprecated/mapnav/tests/api-contract/test_retrieval_mapnav_session_contract.py @@ -16,7 +16,7 @@ ) from shared.services.retrieval.execution.route_types import RetrievalRouteContext from shared.services.retrieval.nav._compat import AgentStep, Chunk, EpisodeResult -from shared.services.retrieval.nav.nav_knowhere import SectionRow, UnitRow +from shared.services.retrieval.scoring.knowhere_provider import SectionRow, UnitRow from shared.services.retrieval.nav_snapshot import build_nav_snapshot RouteRow = dict[str, object] diff --git a/apps/api/tests/contract/test_retrieval_relit_map_cache_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_relit_map_cache_contract.py similarity index 100% rename from apps/api/tests/contract/test_retrieval_relit_map_cache_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_relit_map_cache_contract.py diff --git a/apps/api/tests/contract/test_retrieval_snapshot_batching_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_snapshot_batching_contract.py similarity index 100% rename from apps/api/tests/contract/test_retrieval_snapshot_batching_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_snapshot_batching_contract.py diff --git a/apps/api/tests/contract/test_retrieval_snapshot_consistency_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_snapshot_consistency_contract.py similarity index 100% rename from apps/api/tests/contract/test_retrieval_snapshot_consistency_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_snapshot_consistency_contract.py diff --git a/apps/api/tests/contract/test_retrieval_snapshot_large_corpus_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_snapshot_large_corpus_contract.py similarity index 100% rename from apps/api/tests/contract/test_retrieval_snapshot_large_corpus_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_snapshot_large_corpus_contract.py diff --git a/apps/api/tests/contract/test_retrieval_snapshot_redis_contract.py b/deprecated/mapnav/tests/api-contract/test_retrieval_snapshot_redis_contract.py similarity index 100% rename from apps/api/tests/contract/test_retrieval_snapshot_redis_contract.py rename to deprecated/mapnav/tests/api-contract/test_retrieval_snapshot_redis_contract.py diff --git a/packages/shared-python/shared/tests/test_nav_bridge_config.py b/deprecated/mapnav/tests/shared/test_nav_bridge_config.py similarity index 98% rename from packages/shared-python/shared/tests/test_nav_bridge_config.py rename to deprecated/mapnav/tests/shared/test_nav_bridge_config.py index 89e8469d..1ee16569 100644 --- a/packages/shared-python/shared/tests/test_nav_bridge_config.py +++ b/deprecated/mapnav/tests/shared/test_nav_bridge_config.py @@ -14,7 +14,7 @@ os.environ.setdefault("S3_TEMP_PATH", "/tmp") from shared.services.retrieval.nav._compat import Chunk -from shared.services.retrieval.nav.nav_knowhere import SectionRow, UnitRow +from shared.services.retrieval.scoring.knowhere_provider import SectionRow, UnitRow from shared.services.retrieval.nav_bridge import build_referenced_chunks from shared.services.retrieval.nav_config import ( MAPNAV_MODEL, diff --git a/packages/shared-python/shared/tests/test_nav_llm_backend.py b/deprecated/mapnav/tests/shared/test_nav_llm_backend.py similarity index 100% rename from packages/shared-python/shared/tests/test_nav_llm_backend.py rename to deprecated/mapnav/tests/shared/test_nav_llm_backend.py diff --git a/packages/shared-python/shared/tests/test_nav_node_filter.py b/deprecated/mapnav/tests/shared/test_nav_node_filter.py similarity index 93% rename from packages/shared-python/shared/tests/test_nav_node_filter.py rename to deprecated/mapnav/tests/shared/test_nav_node_filter.py index ef662b64..bca04462 100644 --- a/packages/shared-python/shared/tests/test_nav_node_filter.py +++ b/deprecated/mapnav/tests/shared/test_nav_node_filter.py @@ -2,18 +2,18 @@ from __future__ import annotations -from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace -from shared.services.retrieval.nav.nav_knowhere import ( +from shared.services.retrieval.nav.nav_knowhere import NamespaceKnowhereProvider +from shared.services.retrieval.scoring.hierarchy import ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_provider import ( KnowhereProvider, - NamespaceKnowhereProvider, SectionRow, ) from shared.services.retrieval.nav.nav_node_filter import ( apply_node_filter, - field_predicate, node_filter, render_submap_observation, ) +from shared.services.retrieval.scoring.node_filter_predicates import field_predicate def _section( diff --git a/packages/shared-python/shared/tests/test_nav_node_filter_wire.py b/deprecated/mapnav/tests/shared/test_nav_node_filter_wire.py similarity index 97% rename from packages/shared-python/shared/tests/test_nav_node_filter_wire.py rename to deprecated/mapnav/tests/shared/test_nav_node_filter_wire.py index f3129736..1025a647 100644 --- a/packages/shared-python/shared/tests/test_nav_node_filter_wire.py +++ b/deprecated/mapnav/tests/shared/test_nav_node_filter_wire.py @@ -4,10 +4,10 @@ from typing import Any -from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace -from shared.services.retrieval.nav.nav_knowhere import ( +from shared.services.retrieval.nav.nav_knowhere import NamespaceKnowhereProvider +from shared.services.retrieval.scoring.hierarchy import ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_provider import ( KnowhereProvider, - NamespaceKnowhereProvider, SectionRow, ) from shared.services.retrieval.nav.nav_orchestrate import _execute_subgoal_harvest_once diff --git a/packages/shared-python/shared/tests/test_nav_plan_node_filter.py b/deprecated/mapnav/tests/shared/test_nav_plan_node_filter.py similarity index 100% rename from packages/shared-python/shared/tests/test_nav_plan_node_filter.py rename to deprecated/mapnav/tests/shared/test_nav_plan_node_filter.py diff --git a/packages/shared-python/shared/tests/test_nav_plan_query_only.py b/deprecated/mapnav/tests/shared/test_nav_plan_query_only.py similarity index 100% rename from packages/shared-python/shared/tests/test_nav_plan_query_only.py rename to deprecated/mapnav/tests/shared/test_nav_plan_query_only.py diff --git a/packages/shared-python/shared/tests/test_nav_projection_prod.py b/deprecated/mapnav/tests/shared/test_nav_projection_prod.py similarity index 95% rename from packages/shared-python/shared/tests/test_nav_projection_prod.py rename to deprecated/mapnav/tests/shared/test_nav_projection_prod.py index 1d5219d6..d03a30ba 100644 --- a/packages/shared-python/shared/tests/test_nav_projection_prod.py +++ b/deprecated/mapnav/tests/shared/test_nav_projection_prod.py @@ -12,8 +12,8 @@ os.environ.setdefault("S3_SECRET_ACCESS_KEY", "test") os.environ.setdefault("S3_TEMP_PATH", "/tmp") -from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace -from shared.services.retrieval.nav.nav_knowhere import SectionRow, UnitRow +from shared.services.retrieval.scoring.hierarchy import ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_provider import SectionRow, UnitRow from shared.services.retrieval.nav.nav_projection import ( _section_summary_for_map, build_map, diff --git a/packages/shared-python/shared/tests/test_nav_scope_filter.py b/deprecated/mapnav/tests/shared/test_nav_scope_filter.py similarity index 95% rename from packages/shared-python/shared/tests/test_nav_scope_filter.py rename to deprecated/mapnav/tests/shared/test_nav_scope_filter.py index 2228d362..ecf02fc9 100644 --- a/packages/shared-python/shared/tests/test_nav_scope_filter.py +++ b/deprecated/mapnav/tests/shared/test_nav_scope_filter.py @@ -5,13 +5,14 @@ import json from typing import Any, List -from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace -from shared.services.retrieval.nav.nav_knowhere import ( +from shared.services.retrieval.nav.nav_knowhere import NamespaceKnowhereProvider +from shared.services.retrieval.scoring.hierarchy import ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_provider import ( KnowhereProvider, - NamespaceKnowhereProvider, SectionRow, ) -from shared.services.retrieval.nav.nav_node_filter import field_predicate, node_filter +from shared.services.retrieval.nav.nav_node_filter import node_filter +from shared.services.retrieval.scoring.node_filter_predicates import field_predicate from shared.services.retrieval.nav.nav_scope_filter import run_scope_filter from shared.services.retrieval.nav.nav_types import NavConfig diff --git a/packages/shared-python/shared/tests/test_nav_snapshot.py b/deprecated/mapnav/tests/shared/test_nav_snapshot.py similarity index 97% rename from packages/shared-python/shared/tests/test_nav_snapshot.py rename to deprecated/mapnav/tests/shared/test_nav_snapshot.py index f8bf76f6..76911ac1 100644 --- a/packages/shared-python/shared/tests/test_nav_snapshot.py +++ b/deprecated/mapnav/tests/shared/test_nav_snapshot.py @@ -13,7 +13,7 @@ import pytest -from shared.services.retrieval.nav.nav_knowhere import SectionRow, UnitRow +from shared.services.retrieval.scoring.knowhere_provider import SectionRow, UnitRow from shared.services.retrieval.nav_snapshot import build_nav_snapshot diff --git a/packages/shared-python/shared/tests/test_nav_stamp.py b/deprecated/mapnav/tests/shared/test_nav_stamp.py similarity index 100% rename from packages/shared-python/shared/tests/test_nav_stamp.py rename to deprecated/mapnav/tests/shared/test_nav_stamp.py diff --git a/packages/shared-python/shared/tests/test_nav_trace_map.py b/deprecated/mapnav/tests/shared/test_nav_trace_map.py similarity index 100% rename from packages/shared-python/shared/tests/test_nav_trace_map.py rename to deprecated/mapnav/tests/shared/test_nav_trace_map.py diff --git a/packages/shared-python/shared/services/retrieval/trace/mapnav.py b/deprecated/mapnav/trace_mapnav.py similarity index 100% rename from packages/shared-python/shared/services/retrieval/trace/mapnav.py rename to deprecated/mapnav/trace_mapnav.py diff --git a/docs/design/retrieval-heart-vessel-trace-optimization-plan.md b/docs/design/retrieval-heart-vessel-trace-optimization-plan.md index ed62a57b..f4521260 100644 --- a/docs/design/retrieval-heart-vessel-trace-optimization-plan.md +++ b/docs/design/retrieval-heart-vessel-trace-optimization-plan.md @@ -17,7 +17,7 @@ request, not a historical request: - Trace: `01a05e530f7787333c0e32ca16633b85` - Route: `/api/v1/retrieval/query` - HTTP status: `200` -- Router: `mapnav` +- Router: `agent_explore` - Stop reason: `completed` - Server span: `42.365 s` - Client wall time: `44.690 s` @@ -302,13 +302,13 @@ Acceptance criteria: demonstrated; otherwise this remains a validation note, not an optimization slice; - selected chunk IDs, scores, ordering, and evidence remain unchanged; -- benchmark results record the route family (`classic`, `mapnav`, or +- benchmark results record the route family (`classic`, `agent_explore`, or `small_corpus`) and separate cold, warm, and response-cache-hit requests; cache-hit timings are not mixed into cold-request latency claims. ### P0: Make map-unit projection token-selective -The current map-nav reader already makes its frequency lookup token-selective, +The current map-unit reader already makes its frequency lookup token-selective, but it still loads every revision-scoped map unit before applying the query tokens. Change only the unit projection: start from `document_map_unit_tokens` filtered by `channel` and `token_hash`, then join the diff --git a/docs/design/retrieval-serving-index-rollout-runbook.md b/docs/design/retrieval-serving-index-rollout-runbook.md index 56d2c3cc..2d91c97b 100644 --- a/docs/design/retrieval-serving-index-rollout-runbook.md +++ b/docs/design/retrieval-serving-index-rollout-runbook.md @@ -153,15 +153,16 @@ index with `DROP INDEX CONCURRENTLY`, and rerun the migration. Deploy the application after the additive migrations finish. New publications will write coherent format-v2 statistics. Existing revisions with NULL channel statistics remain on the full scope-first map-unit reader until maintenance -completes; missing, legacy, or unusable indexes remain on the legacy reader. +completes; missing, legacy, or unusable indexes raise. Immediately verify: - API health checks pass; - no migration or model-loading error appears in API logs; -- classic and map-nav requests still complete; +- classic and agent_explore requests still complete; - incomplete-index warnings distinguish statistics-incomplete map-unit serving - from `fallback=legacy_fts`; neither case may return partial or empty results; + from an unusable index, which must raise; statistics-incomplete serving + must not return partial or empty results; - no increase appears in retrieval errors or timeouts. ## Phase 4: Backfill existing format-v2 indexes @@ -317,12 +318,12 @@ Exercise at least: 1. v1 `use_agentic=false`; 2. v2 `use_agentic=false` with equivalent retrieval fields; -3. one `use_agentic=true` map-nav smoke; -4. one request with `use_agentic` omitted, confirming it routes to map-nav; +3. one `use_agentic=true` agent_explore smoke; +4. one request with `use_agentic` omitted, confirming it routes to agent_explore; 5. one filtered request, confirming filtered-scope semantics and the safe fallback where required. -Map-nav LLM output is nondeterministic. For production smoke, require successful +Agent-explore LLM output is nondeterministic. For production smoke, require successful completion, valid citations, expected namespace isolation, and relevant evidence. Do not require byte-identical ordering between independent Planner runs. Deterministic map-score parity remains covered by the contract suite. @@ -339,13 +340,13 @@ recorded baseline, and retrieval error/timeout rates must not regress. - retrieval request p50/p95 and maximum latency, separated by `router_used`; - classic `search.map_unit_discovery` stages: units, frequencies, indexes, statistics, scoring, and hydration; -- map-nav snapshot, episode, and hydration stages; +- agent_explore episode, tool, and hydration stages; - PostgreSQL statement timeouts, lock waits, CPU, I/O, and connection usage; - Redis errors and namespace snapshot cache misses; -- retrieval errors, incomplete-index fallbacks, and response timeouts; -- process CPU and maximum RSS from the corrected map-nav resource log. +- retrieval errors, unusable-index failures, and response timeouts; +- process CPU and maximum RSS from agent_explore resource logs. -Do not mix classic and map-nav latency distributions. Do not treat Redis-warm +Do not mix classic and agent_explore latency distributions. Do not treat Redis-warm snapshot measurements as cold-request performance. ## Pause and resume @@ -365,7 +366,7 @@ If application errors, timeouts, or quality regressions occur: 1. stop the backfill process; 2. redeploy the previous application version; -3. verify classic and map-nav requests using the frozen quality set; +3. verify classic and agent_explore requests using the frozen quality set; 4. retain the additive columns, index, and already-computed statistics unless database health specifically requires their removal. @@ -387,7 +388,7 @@ Attach the following to the deployment ticket: - final `--check` output; - ready/current revision counts; - frozen-query parity results; -- classic and map-nav latency summaries; +- classic and agent_explore latency summaries; - observed fallback, error, and timeout counts; - rollback decision or explicit confirmation that rollback was not required. diff --git a/docs/design/retrieval-streaming-sse.md b/docs/design/retrieval-streaming-sse.md index b0b5a73e..47420fde 100644 --- a/docs/design/retrieval-streaming-sse.md +++ b/docs/design/retrieval-streaming-sse.md @@ -7,7 +7,7 @@ ## Purpose Online Brain users currently wait for a complete retrieval response while -map-nav planning, searching, source review, and final hydration run. This +agentic retrieval, tool calls, and final hydration run. This design makes that work visible without exposing chain-of-thought or changing who owns answer generation. @@ -61,7 +61,7 @@ response as the authoritative result: "sequence": 7, "elapsed_ms": 2410, "status": "completed", - "response": { "namespace": "default", "query": "...", "router_used": "mapnav", "evidence_text": "...", "referenced_chunks": [], "results": [] } + "response": { "namespace": "default", "query": "...", "router_used": "agent_explore", "evidence_text": "...", "referenced_chunks": [], "results": [] } } ``` @@ -90,9 +90,9 @@ terminal SSE event because the HTTP status can no longer be changed. ## Internal implementation seam -Keep the synchronous map-nav implementation. Add an optional callback that -receives a sanitized progress projection after each completed planner, -search, or review step. The SSE route bridges this callback to an +Keep the live retrieval implementation. Add an optional callback that +receives a sanitized progress projection after each completed agent +or classic step. The SSE route bridges this callback to an `asyncio.Queue` using a thread-safe loop handoff while retrieval continues in its existing worker thread. @@ -106,12 +106,12 @@ Add cooperative cancellation checks between steps. An in-flight synchronous provider call may finish before cancellation takes effect. Cancelled runs do not perform final hydration when cancellation is observed in time. -Phase ownership is explicit: the route emits `started`; the map-nav adapter -emits `planning` before `plan_query` and `searching` before navigation or -classic discovery; the route emits `reviewing_sources` after retrieval -selection and before reference hydration; and it emits `finalizing` before -public projection. Counts are sourced from existing snapshot, reference, and -assembled-result counts and are omitted when not yet known. +Phase ownership is explicit: the route emits `started`; the live route +emits `searching` during classic discovery or agent_explore tool steps; the +route emits `reviewing_sources` after retrieval selection and before +reference hydration; and it emits `finalizing` before public projection. +Counts are sourced from existing reference and assembled-result counts and +are omitted when not yet known. ## Correct duration accounting @@ -132,15 +132,15 @@ Required changes: - pass the execution start timestamp into `TraceRecorder`; - set `retrieval_runs.latency_ms` from that timestamp; - record cache-hit runs with the same definition; -- ensure classic, map-nav, small-corpus, cache-hit, failed, and cancelled +- ensure classic, agent_explore, small-corpus, cache-hit, failed, and cancelled retrievals all have an explicit timing/observability outcome; - expose separate `time_to_first_event_ms`, `retrieval_latency_ms`, and downstream `time_to_first_token_ms` measurements; - retain per-step `elapsed_ms` as step latency, not total request latency. -`retrieval_runs` is the ledger for every retrieval execution, not only -map-nav. Each row records the route type, `agentic_enabled`, `cache_hit`, -canonical latency, and terminal status for classic, map-nav, small-corpus, +`retrieval_runs` is the ledger for every retrieval execution. Each row +records the route type, `agentic_enabled`, `cache_hit`, +canonical latency, and terminal status for classic, agent_explore, small-corpus, cache-hit, failed, and cancelled runs. Add a backward-compatible status field and migration rather than overloading free-form error text. @@ -186,7 +186,7 @@ later local constructor time or include its own flush duration. ## Verification gates -- correct phase order for map-nav, classic, and small-corpus routes; +- correct phase order for agent_explore, classic, and small-corpus routes; - cache-hit streams emit only applicable phases and identify the cache hit; - no sensitive planner or evidence data before the terminal event; - terminal citations match the existing JSON endpoint; diff --git a/packages/shared-python/shared/models/database/document.py b/packages/shared-python/shared/models/database/document.py index 6a46fdd2..5b847ab9 100644 --- a/packages/shared-python/shared/models/database/document.py +++ b/packages/shared-python/shared/models/database/document.py @@ -7,7 +7,6 @@ from uuid import uuid4 from sqlalchemy import ( - Computed, JSON, DateTime, Float, @@ -20,7 +19,6 @@ Text, UniqueConstraint, ) -from sqlalchemy.dialects.postgresql import TSVECTOR from sqlalchemy.orm import Mapped, mapped_column, relationship from shared.core.database import Base @@ -176,22 +174,6 @@ class DocumentChunk(Base): content_search_text: Mapped[Optional[str]] = mapped_column(Text, nullable=True) path_search_text: Mapped[Optional[str]] = mapped_column(Text, nullable=True) term_search_text: Mapped[Optional[str]] = mapped_column(Text, nullable=True) - content_search_tsv: Mapped[Optional[str]] = mapped_column( - TSVECTOR, - Computed( - "to_tsvector('simple', COALESCE(content_search_text, ''))", - persisted=True, - ), - nullable=True, - ) - path_search_tsv: Mapped[Optional[str]] = mapped_column( - TSVECTOR, - Computed( - "to_tsvector('simple', COALESCE(path_search_text, ''))", - persisted=True, - ), - nullable=True, - ) source_chunk_path: Mapped[Optional[str]] = mapped_column(Text, nullable=True) file_path: Mapped[Optional[str]] = mapped_column(Text, nullable=True) chunk_metadata: Mapped[Optional[Dict[str, Any]]] = mapped_column( @@ -232,16 +214,6 @@ class DocumentChunk(Base): "id", ), Index("idx_document_chunks_section", "section_id"), - Index( - "idx_chunk_content_search_tsv", - "content_search_tsv", - postgresql_using="gin", - ), - Index( - "idx_chunk_path_search_tsv", - "path_search_tsv", - postgresql_using="gin", - ), ) diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py b/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py index 8988dbd9..d313f765 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/__init__.py @@ -1,19 +1,11 @@ """In-process tool-calling agentic retrieval route. -See ``.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md`` -(Phase 3) for the design. Runs the ``agent_tools`` corpus registry through an -LLM tool-calling loop instead of map-nav's PLANNER/HARVEST/CONTROL episode. -Selected via ``RETRIEVAL_AGENTIC_ROUTER=agent_explore`` -(``execution/routes.py``); ``mapnav`` remains the default until this route -passes its Phase 4 evaluation gate. +Default agentic path when ``use_agentic`` is unset or true. Runs the +``agent_tools`` corpus registry through an LLM tool-calling loop. Map-nav is +archived under ``deprecated/mapnav/`` and is not a live route. -Which provider runs that loop (OpenAI-compatible/DeepSeek, Cursor SDK) is a -second, independent switch — ``AGENT_EXPLORE_HARNESS`` — resolved via -``resolve_harness()``. See ``harness/`` (Phase 3.5) for the pluggable -``Harness`` interface and its two implementations. - -No runtime dependency on ``shared.services.retrieval.nav`` — see -``config.py``'s module docstring. +Which provider runs that loop (Cursor SDK or OpenAI-compatible) is the +``AGENT_EXPLORE_HARNESS`` switch resolved via ``resolve_harness()``. """ from __future__ import annotations diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/bridge.py b/packages/shared-python/shared/services/retrieval/agent_explore/bridge.py index 8b114ed9..4f840426 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/bridge.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/bridge.py @@ -2,9 +2,7 @@ ``DecisionTraceStep`` / ``TraceRecorder`` (``shared/services/retrieval/trace/``) are already provider-agnostic — this module only maps this package's own -``AgentStep`` records onto that shared shape, mirroring what -``trace/mapnav.py`` does for the map-nav episode object, without importing -anything from ``nav/``. +``AgentStep`` records onto that shared shape. """ from __future__ import annotations @@ -12,10 +10,7 @@ from shared.services.retrieval.agent_explore.types import AgentStep from shared.services.retrieval.trace import DecisionTraceStep -# Mirrors nav_config.MAPNAV_TRACE_RAW_CHARS's existing practice of capping -# raw trace text before it goes into the public decision_trace response — -# redeclared locally (not imported) to keep this package decoupled from -# nav_config.py per config.py's module docstring. +# Cap raw trace text before it goes into the public decision_trace response. TRACE_OBSERVATION_MAX_CHARS = 2_000 diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/config.py b/packages/shared-python/shared/services/retrieval/agent_explore/config.py index 961003cf..0d467633 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/config.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/config.py @@ -1,21 +1,9 @@ """Production config for the ``agent_explore`` in-process tool-loop. -Deliberately independent from ``nav_config.py`` / ``nav/`` — see -``nav_config.py``'s "not read by agent_explore" note. This package must have -no runtime import from ``nav/`` so Phase 5 can delete that package once -``agent_explore`` passes its Phase 4 evaluation gate, without having to first -extract anything out of ``nav/`` for this package to keep working. - -Model choice: reuses the same literal model name as ``nav_config.MAPNAV_MODEL`` -(``deepseek-v4-flash``) — not by importing that module, but as its own -constant — because tool-calling (single, parallel, and forced ``tool_choice``) -was verified live against this exact model during Phase 3 design; no other -model has been verified for this codebase's OpenAI-compatible client. - -``AGENT_EXPLORE_MAX_STEPS`` / ``AGENT_EXPLORE_WALL_CLOCK_SECONDS`` are new -product constants (not specified by the plan text, which only named the two -budget *dimensions* to add). Disclosed here rather than buried: revisit in -Phase 4 evaluation once real latency data exists. +Model choice for the OpenAI-compatible harness is ``deepseek-v4-flash``: +tool-calling (single, parallel, and forced ``tool_choice``) was verified +live against this exact model; no other model has been verified for this +codebase's OpenAI-compatible client. """ from __future__ import annotations @@ -32,8 +20,7 @@ AGENT_EXPLORE_CURSOR_MODEL = "composer-2.5" # One LLM turn = one round-trip that may contain several parallel tool calls -# (see episode.py). Kept low relative to map-nav's per-node dispatch depth -# (≤5) because each turn here can already resolve several tools at once. +# (see episode.py). AGENT_EXPLORE_MAX_STEPS = 12 # Wall-clock ceiling for the whole episode (LLM round-trips + tool diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py index 8196f05b..0d84b566 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py @@ -9,11 +9,10 @@ ``config.AGENT_EXPLORE_CURSOR_MODEL``, e.g. ``composer-2.5``) instead of DeepSeek. -Requires the optional ``cursor-sdk`` dependency (see -``apps/worker/pyproject.toml``'s ``cursor-harness`` extra) and -``CURSOR_API_KEY``. The guarded import in ``_require_cursor_sdk`` raises a -clear, actionable error at harness-selection time if ``cursor-sdk`` isn't -installed, instead of failing deep inside a running episode. +Requires ``cursor-sdk`` (base dependency of ``apps/api``; worker debug +scripts use the ``cursor-harness`` extra) and ``CURSOR_API_KEY``. The +guarded import in ``_require_cursor_sdk`` raises a clear error at episode +start if ``cursor-sdk`` isn't installed. Architectural difference from ``openai_harness.py`` that budget enforcement has to work around: this harness does not control the LLM turn loop. @@ -116,10 +115,10 @@ def _require_cursor_sdk() -> Any: import cursor_sdk except ImportError as exc: raise RuntimeError( - "AGENT_EXPLORE_HARNESS=cursor_sdk requires the optional " + "AGENT_EXPLORE_HARNESS=cursor_sdk requires the " "'cursor-sdk' dependency, which is not installed in this " - "interpreter. Install with: uv sync --extra cursor-harness " - "(apps/worker/pyproject.toml)." + "interpreter. For the API service it is a base dependency " + "(apps/api). Worker debug scripts: uv sync --extra cursor-harness." ) from exc return cursor_sdk diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py index 0f86c2fd..2d48f505 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py @@ -18,7 +18,7 @@ by design, not because concurrent dispatch would be unsafe (it no longer is — see ``dispatch.py``). -No import from ``nav/`` or ``nav_config.py`` — see ``config.py``. +No import from archived map-nav modules. Two Phase 4 fixes (audited live against the eval fixture in ``apps/worker/scripts/fixtures/changheba_archive_eval_queries.json``), both @@ -89,9 +89,7 @@ def _resolve_client_and_model() -> tuple[Any, str]: - """Mirrors ``nav_llm_backend.nav_chat_sync_backend``'s resolve pattern, - pinned to ``AGENT_EXPLORE_MODEL`` instead of ``nav_config.MAPNAV_MODEL``. - """ + """Resolve the OpenAI-compatible client and ``AGENT_EXPLORE_MODEL``.""" from shared.services.ai.llm_overrides import resolve_text from shared.services.ai.openai_compatible_client_sync import get_openai_client diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/resolve.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/resolve.py index 449a636e..cf19cd86 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/resolve.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/resolve.py @@ -1,7 +1,6 @@ -"""``AGENT_EXPLORE_HARNESS`` env switch — same pattern as ``execution/routes.py``'s -``_resolve_agentic_router()`` (``RETRIEVAL_AGENTIC_ROUTER``): unrecognized or -unset values fall back to the default rather than raising, so a typo'd env -var degrades to known-good behavior instead of breaking the route. +"""``AGENT_EXPLORE_HARNESS`` env switch: unrecognized or unset values fall +back to the default rather than raising, so a typo'd env var degrades to +known-good behavior instead of breaking the route. Each branch below imports its harness implementation lazily so that selecting ``openai`` never imports ``cursor_sdk``-dependent code (and @@ -16,11 +15,11 @@ _HARNESS_ENV = "AGENT_EXPLORE_HARNESS" _HARNESSES = {"openai", "cursor_sdk"} -_DEFAULT_HARNESS = "openai" +_DEFAULT_HARNESS = "cursor_sdk" def resolve_harness_name() -> str: - """``openai`` (default, current production behavior) or ``cursor_sdk``.""" + """``cursor_sdk`` (default) or ``openai``.""" value = os.environ.get(_HARNESS_ENV, "").strip().lower() return value if value in _HARNESSES else _DEFAULT_HARNESS diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/shared.py b/packages/shared-python/shared/services/retrieval/agent_explore/shared.py index 6b37821f..36223c4d 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/shared.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/shared.py @@ -57,7 +57,7 @@ def tool_message_content(result: ToolResult, *, max_chars: int) -> str: """Cap a tool's rendered text before it enters LLM context. Uses the caller's ``ToolBudget.max_chars`` (``EVIDENCE_TEXT_CHAR_BUDGET``, - aligned with map-nav evidence packing — see ``agent_tools/registry.py``) + aligned with evidence packing — see ``agent_tools/registry.py``) so tools like ``read`` can return unbounded body text while the harness still bounds what the model sees per turn. This cap applies uniformly to every tool's rendered text (not just ``read``'s body content) — a tool diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/registry.py b/packages/shared-python/shared/services/retrieval/agent_tools/registry.py index 61861fd0..d5aa871c 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/registry.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/registry.py @@ -39,7 +39,7 @@ class ToolBudget: context. Applied in ``agent_explore.shared.tool_message_content`` (not inside individual tools) so ``read`` can return full body text from the tool while the harness still bounds what the model sees per turn. Aligned - with map-nav final evidence packing via ``EVIDENCE_TEXT_CHAR_BUDGET`` + with final evidence packing via ``EVIDENCE_TEXT_CHAR_BUDGET`` (12_000). """ diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py index d715a063..6c0269fa 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/node_filter.py @@ -1,7 +1,7 @@ """``corpus.node_filter`` — deterministic FOR-ALL/EXISTS/ANY/NOT predicate over sections. Reuses the exact predicate compile/match semantics from -``nav.nav_node_filter`` (path/summary substring|regex, fields AND together, +``scoring.node_filter_predicates`` (path/summary substring|regex, fields AND together, terms OR together) — see that module's docstring — but walks ``document_sections`` rows for the requested documents' current revision instead of the in-memory map-nav tree. No top-K: returns the full matched set @@ -20,7 +20,7 @@ ToolResult, register_tool, ) -from shared.services.retrieval.nav.nav_node_filter import ( +from shared.services.retrieval.scoring.node_filter_predicates import ( FieldPredicate, _compile_predicates, _node_matches, diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py b/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py index 57523885..6e906cd6 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/tools/recall.py @@ -8,9 +8,7 @@ (persisted map-unit BM25 over path+content, already RRF-fused internally). - ``term``: a fresh substring channel over ``document_map_units.term_search_text_lower`` — this column is persisted at - index time but, before this tool, was only read by map_unit_discovery's - *legacy* PG-FTS fallback, never as an independently-ranked channel (see - ``search/map_unit_discovery.py`` module docstring and AGENTS.md Stage ⑤). + index time and is ranked here as an independent substring channel. ``vector`` is accepted in ``channels`` but rejected as reserved/not implemented (``CORPUS_SCHEMA.md`` §5) — it is not silently ignored. @@ -19,7 +17,7 @@ channel (term) at equal RRF weight is a necessary, disclosed design choice: there is no persisted precedent for a different weight ratio between them (the old 3-channel weights of path=1.0/content=2.0/term=1.5 no longer exist -in code — only path=1.0/content=2.0 survive in ``nav.knowhere_hybrid``). +in code — only path=1.0/content=2.0 survive in ``scoring.knowhere_hybrid``). The term channel's snippet and the rendered ``text`` preview both go through the shared ``agent_tools.snippet.build_snippet`` (head + first-match window + diff --git a/packages/shared-python/shared/services/retrieval/cache_service.py b/packages/shared-python/shared/services/retrieval/cache_service.py index c327eb46..07ea6b6a 100644 --- a/packages/shared-python/shared/services/retrieval/cache_service.py +++ b/packages/shared-python/shared/services/retrieval/cache_service.py @@ -79,6 +79,7 @@ def _cache_shape_digest( use_agentic: bool | None = None, llm_text_model: str | None = None, llm_vision_model: str | None = None, + harness: str | None = None, ) -> str: normalized_excludes = sorted(exclude_document_ids) normalized_sections = _normalize_exclude_sections(exclude_sections) @@ -96,6 +97,7 @@ def _cache_shape_digest( str(use_agentic), str(llm_text_model or ""), str(llm_vision_model or ""), + str(harness or ""), ] ) payload = f"{query}|{top_k}|{'|'.join(normalized_excludes)}|{'|'.join(normalized_sections)}|{extra}" diff --git a/packages/shared-python/shared/services/retrieval/execution/query_request.py b/packages/shared-python/shared/services/retrieval/execution/query_request.py index 9e831bce..c6d3488d 100644 --- a/packages/shared-python/shared/services/retrieval/execution/query_request.py +++ b/packages/shared-python/shared/services/retrieval/execution/query_request.py @@ -8,6 +8,7 @@ from shared.models.schemas.llm_config import LLMConfig from shared.models.schemas.retrieval_namespace import normalize_retrieval_namespace from shared.services.retrieval.execution.route_types import RetrievalRouteContext +from shared.services.retrieval.agent_explore.harness.resolve import resolve_harness_name from shared.services.retrieval.settings import ( INTERNAL_RECALL_K_MULTIPLIER, ) @@ -98,6 +99,9 @@ def build_cache_extra(self) -> dict[str, Any]: "use_agentic": self.use_agentic, "llm_text_model": text_model, "llm_vision_model": vision_model, + "harness": ( + resolve_harness_name() if self.use_agentic is not False else "classic" + ), } def resolve_allowed_chunk_types(self) -> set[str] | None: diff --git a/packages/shared-python/shared/services/retrieval/execution/response_projection.py b/packages/shared-python/shared/services/retrieval/execution/response_projection.py index 656533c6..1ac29076 100644 --- a/packages/shared-python/shared/services/retrieval/execution/response_projection.py +++ b/packages/shared-python/shared/services/retrieval/execution/response_projection.py @@ -16,7 +16,7 @@ def to_public_source(row: dict[str, Any]) -> dict[str, Any]: async def enrich_referenced_chunks_with_asset_url(refs: list[dict[str, Any]]) -> list[dict[str, Any]]: return await enrich_rows_with_retrieval_asset_url( refs, - log_context='mapnav referenced chunk', + log_context='referenced chunk', ) diff --git a/packages/shared-python/shared/services/retrieval/execution/routes.py b/packages/shared-python/shared/services/retrieval/execution/routes.py index 66811ef8..b14a84e9 100644 --- a/packages/shared-python/shared/services/retrieval/execution/routes.py +++ b/packages/shared-python/shared/services/retrieval/execution/routes.py @@ -1,8 +1,5 @@ from __future__ import annotations -import asyncio -import os -import resource import time from contextlib import AbstractAsyncContextManager @@ -26,10 +23,6 @@ count_scoped_chunks, load_all_scoped_chunks, ) -from shared.services.retrieval.execution.revision_pins import ( - capture_revision_pins, - is_revision_generation_stable, -) def open_fresh_database_context() -> AbstractAsyncContextManager[AsyncSession]: @@ -61,20 +54,6 @@ def _render_rows_evidence(rows: list[dict]) -> str: return render_evidence_blocks(list(groups.items())) -_AGENTIC_ROUTERS = {"mapnav", "agent_explore"} -_AGENTIC_ROUTER_ENV = "RETRIEVAL_AGENTIC_ROUTER" - - -def _resolve_agentic_router() -> str: - """``RETRIEVAL_AGENTIC_ROUTER`` env switch: ``mapnav`` (default, current - production route) or ``agent_explore`` (Phase 3 of - ``.cursor/plans/agentic_corpus_explore_retrieval_c2c4ea21.plan.md``, - pending its Phase 4 evaluation gate before it can become the default). - """ - value = os.environ.get(_AGENTIC_ROUTER_ENV, "").strip().lower() - return value if value in _AGENTIC_ROUTERS else "mapnav" - - async def run_retrieval_route( context: RetrievalRouteContext, ) -> RetrievalRouteOutcome: @@ -82,14 +61,10 @@ async def run_retrieval_route( if small_corpus_outcome is not None: return small_corpus_outcome - # Explicit False → classic map-unit BM25 top-K. None/True → agentic, - # routed by RETRIEVAL_AGENTIC_ROUTER (default mapnav). + # Explicit False → classic map-unit BM25 top-K. None/True → agent_explore. if context.use_agentic is False: return await _run_classic_topk_route(context) - - if _resolve_agentic_router() == "agent_explore": - return await _run_agent_explore_route(context) - return await _run_mapnav_route(context) + return await _run_agent_explore_route(context) async def _try_run_small_corpus_route( @@ -211,16 +186,10 @@ async def _run_classic_topk_route( async def _run_agent_explore_route( context: RetrievalRouteContext, ) -> RetrievalRouteOutcome: - """Phase 3 agentic path: in-process ``corpus.*`` tool-calling loop. + """Default agentic path: in-process ``corpus.*`` tool-calling loop. - Selected when ``RETRIEVAL_AGENTIC_ROUTER=agent_explore``; ``mapnav`` - remains the default route until this one passes its Phase 4 evaluation - gate. See ``shared/services/retrieval/agent_explore/``. - - Which provider actually runs the tool-calling loop (OpenAI-compatible - default, or Cursor SDK) is the separate ``AGENT_EXPLORE_HARNESS`` switch - (Phase 3.5) resolved by ``resolve_harness()`` below — independent of - this route selection. + Which provider actually runs the tool-calling loop is the + ``AGENT_EXPLORE_HARNESS`` switch resolved by ``resolve_harness()``. """ from shared.services.retrieval.agent_explore.bridge import build_decision_trace from shared.services.retrieval.agent_explore.budget import EpisodeBudget @@ -325,199 +294,3 @@ async def _run_agent_explore_route( ), ) - -async def _run_mapnav_route( - context: RetrievalRouteContext, -) -> RetrievalRouteOutcome: - """Default agentic path: PLANNER + HARVEST + CONTROL (checklist map-nav). - - LEGACY, PENDING REPLACEMENT: ``agent_explore`` will become the default - agentic route once it passes its evaluation gate; this route then stays - only as the ``RETRIEVAL_AGENTIC_ROUTER=mapnav`` fallback until Phase 5 - cleanup. Do not add new capabilities here — new agentic-retrieval work - belongs in ``shared/services/retrieval/agent_tools/`` and - ``shared/services/retrieval/agent_explore/``. - """ - process_started = resource.getrusage(resource.RUSAGE_SELF) - from shared.services.retrieval import nav_llm_backend # noqa: F401 - from shared.services.retrieval.nav import run_nav_episode - from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace - from shared.services.retrieval.nav_bridge import build_referenced_chunks - from shared.services.retrieval.nav_config import ( - MAPNAV_MODEL, - build_nav_config, - nav_evidence_chars, - ) - from shared.services.retrieval.nav_snapshot import load_nav_snapshot - from shared.services.retrieval.trace import ( - TraceRecorder, - build_decision_trace, - episode_selected_doc_ids, - episode_selected_paths, - episode_token_count, - episode_workflow_plan, - ) - - snapshot_started = time.perf_counter() - snapshot_pins = context.revision_pins - snapshot = await load_nav_snapshot( - context.db, - user_id=context.user_id, - namespace=context.namespace, - exclude_document_ids=context.exclude_document_ids, - exclude_sections=context.exclude_sections, - lazy=True, - revision_pins=snapshot_pins, - generation=(snapshot_pins.generation if snapshot_pins is not None else None), - ) - if snapshot_pins is not None and not await is_revision_generation_stable( - context.db, - user_id=context.user_id, - namespace=context.namespace, - pins=snapshot_pins, - ): - snapshot.close() - snapshot_pins = await capture_revision_pins( - context.db, - user_id=context.user_id, - namespace=context.namespace, - ) - snapshot = await load_nav_snapshot( - context.db, - user_id=context.user_id, - namespace=context.namespace, - exclude_document_ids=context.exclude_document_ids, - exclude_sections=context.exclude_sections, - lazy=True, - revision_pins=snapshot_pins, - generation=(snapshot_pins.generation if snapshot_pins is not None else None), - ) - snapshot_seconds = time.perf_counter() - snapshot_started - logger.info( - "retrieval mapnav stage=snapshot_load seconds={:.3f} documents={} refs={} " - "conversation_id={}".format( - snapshot_seconds, - len(snapshot.document_ids), - len(snapshot.chunk_ref_index), - context.conversation_id or "", - ) - ) - - # Small-corpus count / snapshot reads may leave a checkout; drop it before - # the sync LLM episode (same pattern as the retired workflow route). - await context.db.rollback() - - budget = nav_evidence_chars() - cfg = build_nav_config() - toolspace = ProviderToolSpace(snapshot.provider) - - episode_started = time.perf_counter() - try: - episode = await asyncio.to_thread( - run_nav_episode, - None, - context.query, - corpus_doc_ids=list(snapshot.document_ids), - budget_chars=budget, - compose_answer=False, - policy="llm", - config=cfg, - toolspace=toolspace, - ) - - refs, score_by_chunk_id = build_referenced_chunks(episode, snapshot) - logger.info( - "retrieval mapnav stage=episode seconds={:.3f} refs={}".format( - time.perf_counter() - episode_started, - len(refs), - ) - ) - finally: - snapshot.close() - - hydration_started = time.perf_counter() - async with open_fresh_database_context() as final_db: - resolved = await resolve_workflow_references( - db=final_db, - user_id=context.user_id, - namespace=context.namespace, - refs=refs, - score_by_chunk_id=score_by_chunk_id or None, - revision_pins=snapshot.document_revisions, - ) - assembled_rows = await assemble_retrieval_results( - db=final_db, - rows=resolved.rows, - exclude_document_ids=context.exclude_document_ids, - exclude_sections=context.exclude_sections, - allowed_chunk_types=context.allowed_chunk_types, - revision_pins=snapshot.document_revisions, - ) - - decision_steps = build_decision_trace( - episode, - evidence_char_budget=budget, - n_refs=len(resolved.refs), - ) - decision_trace = [step.to_dict() for step in decision_steps] - selected_paths = episode_selected_paths(episode, resolved.refs) - selected_docs = episode_selected_doc_ids(resolved.refs) - tokens_used = episode_token_count(episode) - trace = TraceRecorder( - final_db, - user_id=context.user_id, - namespace=context.namespace, - query=context.query, - top_k=context.top_k, - chunk_types=context.allowed_chunk_types, - workflow_plan=episode_workflow_plan(episode), - policy_name="mapnav_checklist_v1", - ) - await trace.create_run() - for step in decision_steps: - trace.record_decision_trace_step(step) - await trace.complete( - assembled_rows, - "mapnav", - token_count=tokens_used, - model_name=MAPNAV_MODEL, - selected_paths=selected_paths, - selected_doc_ids=selected_docs, - ) - logger.info( - "retrieval mapnav stage=hydration seconds={:.3f} results={}".format( - time.perf_counter() - hydration_started, - len(assembled_rows), - ) - ) - - stop_reason = str(getattr(episode, "stop_reason", "") or "completed") - evidence_text = str(getattr(episode, "evidence_text", "") or "") - response = { - "namespace": context.namespace, - "query": context.query, - "router_used": "mapnav", - "evidence_text": evidence_text, - "answer_text": "", - "referenced_chunks": resolved.refs, - "results": assembled_rows, - "stop_reason": stop_reason, - "decision_trace": decision_trace, - } - - completion_detail = f"chunks | evidence={len(evidence_text)} chars | router=mapnav" - process_finished = resource.getrusage(resource.RUSAGE_SELF) - logger.info( - "retrieval mapnav stage=process_resources cpu_seconds={:.3f} " - "process_max_rss_kb={}", - (process_finished.ru_utime + process_finished.ru_stime) - - (process_started.ru_utime + process_started.ru_stime), - int(process_finished.ru_maxrss), - ) - return RetrievalRouteOutcome( - response=response, - hit_stats_results=resolved.refs, - completion_label="MAPNAV RETRIEVAL", - completion_count=len(resolved.refs), - completion_detail=completion_detail, - ) diff --git a/packages/shared-python/shared/services/retrieval/map_unit_index.py b/packages/shared-python/shared/services/retrieval/map_unit_index.py index ab7a0523..c58e5f8e 100644 --- a/packages/shared-python/shared/services/retrieval/map_unit_index.py +++ b/packages/shared-python/shared/services/retrieval/map_unit_index.py @@ -1,4 +1,4 @@ -"""Publication-time materialization of exact map-nav lexical units.""" +"""Publication-time materialization of persisted map-unit lexical units.""" from __future__ import annotations @@ -16,15 +16,15 @@ DocumentMapUnitToken, DocumentSection, ) -from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace -from shared.services.retrieval.nav.nav_knowhere import ( +from shared.services.retrieval.scoring.hierarchy import ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_hybrid import MAP_UNIT_INDEX_FORMAT_VERSION +from shared.services.retrieval.scoring.knowhere_provider import ( KnowhereProvider, SectionRow, UnitRow, ) -from shared.services.retrieval.nav.nav_map_scores import build_score_units -from shared.services.retrieval.nav.knowhere_hybrid import MAP_UNIT_INDEX_FORMAT_VERSION -from shared.services.retrieval.nav.persisted_score_load import average_idf_from_unit_dfs +from shared.services.retrieval.scoring.persisted_score_load import average_idf_from_unit_dfs +from shared.services.retrieval.scoring.score_units import build_score_units from shared.services.retrieval.publication_models import DocumentPublicationScope __all__ = ["MAP_UNIT_INDEX_FORMAT_VERSION", "replace_document_map_units"] diff --git a/packages/shared-python/shared/services/retrieval/scoring/__init__.py b/packages/shared-python/shared/services/retrieval/scoring/__init__.py new file mode 100644 index 00000000..404eaf74 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/scoring/__init__.py @@ -0,0 +1 @@ +"""Shared retrieval scoring primitives used by publication and classic recall.""" diff --git a/packages/shared-python/shared/services/retrieval/nav/nav_hierarchy.py b/packages/shared-python/shared/services/retrieval/scoring/hierarchy.py similarity index 75% rename from packages/shared-python/shared/services/retrieval/nav/nav_hierarchy.py rename to packages/shared-python/shared/services/retrieval/scoring/hierarchy.py index 577de014..f9dcfe0d 100644 --- a/packages/shared-python/shared/services/retrieval/nav/nav_hierarchy.py +++ b/packages/shared-python/shared/services/retrieval/scoring/hierarchy.py @@ -21,7 +21,7 @@ from __future__ import annotations -from dataclasses import dataclass, field +from dataclasses import dataclass from typing import ( Any, Dict, @@ -41,7 +41,17 @@ ) if TYPE_CHECKING: - from .knowhere_hybrid import PersistedScoreCorpus + from shared.services.retrieval.scoring.knowhere_hybrid import PersistedScoreCorpus + + +@dataclass +class Chunk: + node_id: str + doc_id: str + text: str + line_ids: Tuple[int, ...] + section_id: Optional[str] = None + text_line_id_groups: Optional[Tuple[Tuple[int, ...], ...]] = None @dataclass @@ -107,10 +117,6 @@ class ProviderToolSpace: def __init__(self, provider: HierarchyProvider) -> None: self._provider = provider - def address_level(self, node_id: str): - fn = getattr(self._provider, "address_level", None) - return fn(node_id) if callable(fn) else None - def owner_document(self, node_id: str) -> Optional[str]: fn = getattr(self._provider, "owner_document", None) if not callable(fn): @@ -123,7 +129,7 @@ def document_ids(self) -> List[str]: fn = getattr(self._provider, "document_ids", None) if not callable(fn): return [] - return [str(x) for x in (fn() or ()) if str(x).strip()] + return [str(x) for x in cast(Sequence[Any], fn() or ()) if str(x).strip()] def sections_for_doc(self, doc_id: str) -> List[str]: return [str(s) for s in self._provider.roots(doc_id)] @@ -190,7 +196,7 @@ def _node_unit_span(self, section_id: str) -> Tuple[str, int, int]: unit_text = getattr(self._provider, "unit_text", None) if not callable(self_units) or not callable(unit_text): return "", 0, 0 - units = list(self_units(section_id) or ()) + units = list(cast(Sequence[Any], self_units(section_id) or ())) if not units: return "", 0, 0 first_order = int(getattr(units[0], "sort_order", 0) or 0) @@ -251,8 +257,6 @@ def _node_unit_span(self, section_id: str) -> Tuple[str, int, int]: def _make_chunk( self, node_id: str, doc_id: str, text: str, order: int, section_id: str ) -> Any: - from ._compat import Chunk # type: ignore - return Chunk( node_id=node_id, doc_id=doc_id, @@ -267,7 +271,7 @@ def materialize_self_only_chunks(self, section_id: str, doc_id: str) -> List[Any if not callable(self_units) or not callable(unit_text): return [] out: List[Any] = [] - for unit in self_units(section_id) or (): + for unit in cast(Sequence[Any], self_units(section_id) or ()): text = str(unit_text(unit) or "").strip() if not text: continue @@ -293,9 +297,9 @@ def _materialize_leaf_path_chunks(self, section_id: str, doc_id: str) -> List[An ] # One unit per descendant leaf, plus one per interstitial parent, so - # node ids line up with the keys nav_map_scores.build_score_units emits. + # node ids line up with the keys scoring.score_units.build_score_units emits. out: List[Any] = [] - for leaf_id in leaf_fn(section_id) or (): + for leaf_id in cast(Sequence[Any], leaf_fn(section_id) or ()): text, order, _count = self._node_unit_span(leaf_id) if text: out.append(self._make_chunk(leaf_id, doc_id, text, order, leaf_id)) @@ -320,102 +324,3 @@ def load_persisted_score_corpus( return None return cast(Optional["PersistedScoreCorpus"], fn(doc_ids, queries)) - -@dataclass -class InMemoryNode: - section_id: str - title: str - content: str = "" - children: List[str] = field(default_factory=list) - - -class InMemoryHierarchyProvider: - """Minimal reference ``HierarchyProvider``: no scoring, no ToolSpace. - - Built directly from a ``{doc_id: [InMemoryNode, ...]}`` map plus a - ``{doc_id: [root_section_id, ...]}`` map — the "hierarchy + summary is - enough" claim's simplest possible witness. - """ - - def __init__( - self, - *, - roots_by_doc: Dict[str, Sequence[str]], - nodes: Dict[str, InMemoryNode], - summaries: Optional[Dict[str, str]] = None, - ) -> None: - self._roots_by_doc = {k: list(v) for k, v in roots_by_doc.items()} - self._nodes = dict(nodes) - self._summaries = dict(summaries or {}) - self._parent: Dict[str, str] = {} - for node in self._nodes.values(): - for child_id in node.children: - self._parent[child_id] = node.section_id - self._owner: Dict[str, str] = {} - for doc_id, root_ids in self._roots_by_doc.items(): - stack = list(root_ids) - while stack: - sid = stack.pop() - if sid in self._owner: - continue - self._owner[sid] = doc_id - node = self._nodes.get(sid) - if node: - stack.extend(node.children) - - def owner_document(self, node_id: str) -> Optional[str]: - return self._owner.get(str(node_id or "").strip()) - - def roots(self, doc_id: str) -> Sequence[str]: - return list(self._roots_by_doc.get(doc_id, ())) - - def children(self, section_id: str) -> Sequence[str]: - node = self._nodes.get(section_id) - return list(node.children) if node else [] - - def node_meta(self, section_id: str) -> NodeMeta: - node = self._nodes.get(section_id) - if node is None: - return NodeMeta() - return NodeMeta( - title=node.title, - summary=self._summaries.get(section_id, ""), - has_children=bool(node.children), - ) - - def parent_id(self, section_id: str) -> Optional[str]: - return self._parent.get(section_id) - - def relations(self, section_id: str) -> Tuple[Set[str], Set[str]]: - ancestors: Set[str] = set() - cur = self._parent.get(section_id) - while cur: - ancestors.add(cur) - cur = self._parent.get(cur) - descendants: Set[str] = set() - stack = list(self.children(section_id)) - while stack: - cid = stack.pop() - if cid in descendants: - continue - descendants.add(cid) - stack.extend(self.children(cid)) - return ancestors, descendants - - def content(self, section_id: str) -> str: - node = self._nodes.get(section_id) - if node is None: - return "" - parts: List[str] = [] - - def walk(sid: str) -> None: - cur = self._nodes.get(sid) - if cur is None: - return - if cur.content: - parts.append(cur.content) - for cid in cur.children: - walk(cid) - - walk(section_id) - return "\n".join(parts) diff --git a/packages/shared-python/shared/services/retrieval/nav/knowhere_hybrid.py b/packages/shared-python/shared/services/retrieval/scoring/knowhere_hybrid.py similarity index 99% rename from packages/shared-python/shared/services/retrieval/nav/knowhere_hybrid.py rename to packages/shared-python/shared/services/retrieval/scoring/knowhere_hybrid.py index 6e5a95f8..ca73845b 100644 --- a/packages/shared-python/shared/services/retrieval/nav/knowhere_hybrid.py +++ b/packages/shared-python/shared/services/retrieval/scoring/knowhere_hybrid.py @@ -247,7 +247,7 @@ def empty(cls) -> "_StreamingBm25Stats": def score( self, document_length: int, - frequencies: Dict[str, int], + frequencies: Mapping[str, int], query_tokens: List[str], ) -> float: if ( diff --git a/packages/shared-python/shared/services/retrieval/scoring/knowhere_provider.py b/packages/shared-python/shared/services/retrieval/scoring/knowhere_provider.py new file mode 100644 index 00000000..34c3b5c6 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/scoring/knowhere_provider.py @@ -0,0 +1,342 @@ +"""Publication-time hierarchy provider over section/chunk rows. + +Extracted from the map-nav package so document publication and classic +recall can build map-unit indexes without the episode kernel. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import ( + Any, + Callable, + Dict, + List, + Optional, + Sequence, + Set, + Tuple, +) + +from shared.services.retrieval.scoring.hierarchy import NodeMeta + + +_ASSET_TYPES = ("table", "image") +# Body chunk types that can own a Root-parked asset via connect_to. Both +# chunk-track ("text") and page-track ("page") body chunks can embed assets. +_BODY_CHUNK_TYPES = ("text", "page") +# Knowhere sentinel path for the virtual document container (not a collectable leaf). +ROOT_SECTION_PATH = "Root" + + +@dataclass(frozen=True) +class SectionRow: + """One ``document_sections`` row.""" + + section_id: str + parent_section_id: Optional[str] + section_path: str + section_title: str + section_level: int + summary: str + sort_order: int + + +@dataclass(frozen=True) +class UnitRow: + """One ``document_chunks`` row.""" + + chunk_id: str + section_id: Optional[str] + chunk_type: str + content: str + sort_order: int + source_chunk_path: str = "" + file_path: str = "" + metadata: Dict[str, Any] = field(default_factory=dict) + + +def asset_display_text(unit: UnitRow) -> str: + """Body text for an asset unit, whose ``content`` is only a file path. + + Mirrors knowhere's own assembly: an asset contributes its summary, not its + path. Without this an asset unit is unscorable and unreadable. + """ + meta = unit.metadata or {} + title = str(meta.get("asset_title") or "").strip() + summary = str(meta.get("summary") or "").strip() + ref = unit.file_path or unit.source_chunk_path or unit.content + label = "Table" if unit.chunk_type == "table" else "Image" + parts = [f"[{label}: {ref}]"] if ref else [f"[{label}]"] + if title: + parts.append(title) + if summary: + parts.append(summary) + return "\n".join(parts) + + +def normalize_section_path(path: str) -> str: + """Canonical path for gold/lookup: ``a / b`` (accepts ``a/b`` or ``a / b``).""" + raw = str(path or "").strip().strip("/") + if not raw or raw == ROOT_SECTION_PATH: + return "" + if " / " in raw: + parts = [p.strip() for p in raw.split(" / ") if p.strip()] + else: + parts = [p.strip() for p in raw.split("/") if p.strip()] + return " / ".join(parts) + + +def is_root_section_path(path: str) -> bool: + """True when the raw ``section_path`` is Knowhere's Root container.""" + return str(path or "").strip() == ROOT_SECTION_PATH + + +def _connect_to_targets(metadata: Dict[str, Any]) -> List[str]: + """``chunk_metadata.connect_to[].target`` ids (document order, first wins upstream).""" + raw = metadata.get("connect_to") if isinstance(metadata, dict) else None + if not isinstance(raw, list): + return [] + out: List[str] = [] + for conn in raw: + if not isinstance(conn, dict): + continue + target = str(conn.get("target") or "").strip() + if target: + out.append(target) + return out + + +class KnowhereProvider: + """``HierarchyProvider`` over knowhere section/chunk rows.""" + + def __init__( + self, + *, + doc_id: str, + sections: Sequence[SectionRow], + units: Sequence[UnitRow], + lazy_loader: Optional[Callable[[str], Sequence[UnitRow]]] = None, + known_chunk_ids: Optional[Sequence[str]] = None, + ) -> None: + self.doc_id = str(doc_id) + self._lazy_loader = lazy_loader + self._loaded_sections: Set[str] = set() + self._sections: Dict[str, SectionRow] = {s.section_id: s for s in sections} + self._children: Dict[str, List[str]] = {} + self._roots: List[str] = [] + self._path_to_id: Dict[str, str] = {} + for row in sorted(sections, key=lambda s: (s.sort_order, s.section_id)): + parent = row.parent_section_id + if parent and parent in self._sections: + self._children.setdefault(parent, []).append(row.section_id) + else: + self._roots.append(row.section_id) + key = normalize_section_path(row.section_path) + if key: + self._path_to_id[key] = row.section_id + + self._units_by_section: Dict[str, List[UnitRow]] = {} + self._chunk_ids: Set[str] = set() + if known_chunk_ids: + self._chunk_ids.update( + str(chunk_id).strip() + for chunk_id in known_chunk_ids + if str(chunk_id).strip() + ) + for unit in sorted(units, key=lambda u: (u.sort_order, u.chunk_id)): + sid = unit.section_id + if not sid or sid not in self._sections: + continue + self._units_by_section.setdefault(sid, []).append(unit) + if unit.chunk_id: + self._chunk_ids.add(unit.chunk_id) + self._remount_root_assets() + + def _ensure_section_loaded(self, section_id: str) -> None: + if self._lazy_loader is None or section_id in self._loaded_sections: + return + loaded = list(self._lazy_loader(section_id) or ()) + self._loaded_sections.add(section_id) + if not loaded: + return + current = self._units_by_section.setdefault(section_id, []) + known = {unit.chunk_id for unit in current} + for unit in loaded: + if unit.chunk_id and unit.chunk_id not in known: + current.append(unit) + known.add(unit.chunk_id) + current.sort(key=lambda unit: (unit.sort_order, unit.chunk_id)) + + def _remount_root_assets(self) -> None: + """Reattach Root-FK image|table units to host sections via ``connect_to``. + + Aligns with Knowhere ``resolve_root_asset_owners``: assets whose FK still + points at Root are owned by the text chunk that lists them in + ``metadata.connect_to``. Unresolved Root assets leave the evidence surface. + """ + root_sids = [ + sid + for sid, row in self._sections.items() + if is_root_section_path(row.section_path) + ] + if not root_sids: + return + + root_assets: Dict[str, UnitRow] = {} + for sid in root_sids: + for unit in self._units_by_section.get(sid, ()): + if unit.chunk_type in _ASSET_TYPES and unit.chunk_id: + root_assets[unit.chunk_id] = unit + if not root_assets: + return + + owner_by_asset: Dict[str, str] = {} + for sid, units in self._units_by_section.items(): + row = self._sections.get(sid) + if row is None or is_root_section_path(row.section_path): + continue + for unit in units: + if unit.chunk_type not in _BODY_CHUNK_TYPES: + continue + for target in _connect_to_targets(unit.metadata or {}): + if target in root_assets and target not in owner_by_asset: + owner_by_asset[target] = sid + + touched_owners: Set[str] = set() + for chunk_id, owner_sid in owner_by_asset.items(): + unit = root_assets[chunk_id] + remounted = UnitRow( + chunk_id=unit.chunk_id, + section_id=owner_sid, + chunk_type=unit.chunk_type, + content=unit.content, + sort_order=unit.sort_order, + source_chunk_path=unit.source_chunk_path, + file_path=unit.file_path, + metadata=dict(unit.metadata or {}), + ) + self._units_by_section.setdefault(owner_sid, []).append(remounted) + touched_owners.add(owner_sid) + + for sid in root_sids: + self._units_by_section[sid] = [ + u + for u in self._units_by_section.get(sid, ()) + if u.chunk_type not in _ASSET_TYPES + ] + for sid in touched_owners: + self._units_by_section[sid].sort(key=lambda u: (u.sort_order, u.chunk_id)) + + def owner_document(self, node_id: str) -> Optional[str]: + sid = str(node_id or "").strip() + if not sid: + return None + if sid == self.doc_id or sid in self._sections or sid in self._chunk_ids: + return self.doc_id + return None + + def roots(self, doc_id: str) -> Sequence[str]: + return list(self._roots) if str(doc_id) == self.doc_id else [] + + def children(self, section_id: str) -> Sequence[str]: + return list(self._children.get(section_id, ())) + + def node_meta(self, section_id: str) -> NodeMeta: + row = self._sections.get(section_id) + if row is None: + return NodeMeta() + return NodeMeta( + title=row.section_title, + summary=row.summary, + has_children=bool(self._children.get(section_id)), + ) + + def relations(self, section_id: str) -> Tuple[Set[str], Set[str]]: + ancestors: Set[str] = set() + cur = self._sections.get(section_id) + while cur is not None and cur.parent_section_id: + parent = cur.parent_section_id + if parent in ancestors: + break + ancestors.add(parent) + cur = self._sections.get(parent) + descendants: Set[str] = set() + stack = list(self.children(section_id)) + while stack: + cid = stack.pop() + if cid in descendants: + continue + descendants.add(cid) + stack.extend(self.children(cid)) + return ancestors, descendants + + def content(self, section_id: str) -> str: + units = self.subtree_units(section_id) + return "\n".join(self.unit_text(u) for u in units if self.unit_text(u)) + + def self_units(self, section_id: str) -> List[UnitRow]: + self._ensure_section_loaded(section_id) + return list(self._units_by_section.get(section_id, ())) + + def subtree_units(self, section_id: str) -> List[UnitRow]: + out = list(self.self_units(section_id)) + for cid in self.relations(section_id)[1]: + out.extend(self.self_units(cid)) + out.sort(key=lambda u: (u.sort_order, u.chunk_id)) + return out + + def leaf_ids(self, section_id: str) -> List[str]: + out: List[str] = [] + + def rec(sid: str) -> None: + kids = self.children(sid) + if not kids: + out.append(sid) + return + for kid in kids: + rec(kid) + + rec(section_id) + return out + + def path_titles(self, section_id: str) -> str: + chain: List[str] = [] + cur = self._sections.get(section_id) + while cur is not None: + if cur.section_title: + chain.append(cur.section_title) + parent = cur.parent_section_id + cur = self._sections.get(parent) if parent else None + return " / ".join(reversed(chain)) + + def parent_id(self, section_id: str) -> Optional[str]: + row = self._sections.get(section_id) + return row.parent_section_id if row else None + + def section_path(self, section_id: str) -> str: + row = self._sections.get(section_id) + return str(row.section_path or "") if row else "" + + def resolve_path(self, path: str) -> Optional[str]: + """Map a human/gold path to ``section_id`` (``sec_*``).""" + key = normalize_section_path(path) + if not key: + return None + return self._path_to_id.get(key) + + def unit_text(self, unit: UnitRow) -> str: + if unit.chunk_type in _ASSET_TYPES: + return asset_display_text(unit) + return str(unit.content or "").strip() + + def summaries(self) -> Dict[str, str]: + return { + sid: row.summary + for sid, row in self._sections.items() + if str(row.summary or "").strip() + } + + def all_section_ids(self) -> List[str]: + return list(self._sections) + diff --git a/packages/shared-python/shared/services/retrieval/scoring/node_filter_predicates.py b/packages/shared-python/shared/services/retrieval/scoring/node_filter_predicates.py new file mode 100644 index 00000000..91bfa047 --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/scoring/node_filter_predicates.py @@ -0,0 +1,83 @@ +"""Predicate compile/match for section path/summary filters. + +Extracted from the map-nav tree walker. Live consumers evaluate these +predicates against persisted section rows, not an in-memory episode tree. +""" + +from __future__ import annotations + +import re +from dataclasses import dataclass +from typing import Any, List, Literal, Sequence, Tuple + +MatchKind = Literal["substring", "regex"] +FilterField = Literal["path", "summary"] + +_MAX_REGEX_PATTERN_LEN = 256 + + +@dataclass(frozen=True) +class FieldPredicate: + field: FilterField + terms: Tuple[str, ...] + match: MatchKind = "substring" + + +def field_predicate( + field: str, + terms: Sequence[str], + match: str = "substring", +) -> FieldPredicate: + key = str(field or "").strip().lower() + if key not in {"path", "summary"}: + raise ValueError(f"unsupported filter field: {field!r}") + kind = str(match or "substring").strip().lower() + if kind not in {"substring", "regex"}: + raise ValueError(f"unsupported filter match: {match!r}") + cleaned = tuple(str(term) for term in terms if str(term)) + return FieldPredicate(field=key, terms=cleaned, match=kind) # type: ignore[arg-type] + + +def _compile_predicates( + predicates: Sequence[FieldPredicate], +) -> Tuple[List[Tuple[FieldPredicate, List[Any]]], List[str]]: + compiled: List[Tuple[FieldPredicate, List[Any]]] = [] + failed: List[str] = [] + for pred in predicates: + if pred.match != "regex": + compiled.append((pred, [])) + continue + patterns: List[Any] = [] + ok = True + for term in pred.terms: + if len(term) > _MAX_REGEX_PATTERN_LEN: + failed.append(f"{pred.field}:regex:too_long") + ok = False + break + try: + patterns.append(re.compile(term, flags=re.IGNORECASE)) + except re.error: + failed.append(f"{pred.field}:regex:invalid") + ok = False + break + if ok: + compiled.append((pred, patterns)) + return compiled, failed + + +def _node_matches( + values: dict[str, str], + compiled: Sequence[Tuple[FieldPredicate, List[Any]]], +) -> bool: + if not compiled: + return True + for pred, patterns in compiled: + text = values.get(pred.field, "") + if pred.match == "regex": + if not patterns or not any(p.search(text or "") for p in patterns): + return False + continue + haystack = (text or "").lower() + if not pred.terms or not any(term.lower() in haystack for term in pred.terms): + return False + return True diff --git a/packages/shared-python/shared/services/retrieval/nav/persisted_score_load.py b/packages/shared-python/shared/services/retrieval/scoring/persisted_score_load.py similarity index 96% rename from packages/shared-python/shared/services/retrieval/nav/persisted_score_load.py rename to packages/shared-python/shared/services/retrieval/scoring/persisted_score_load.py index 712f23b5..53924b01 100644 --- a/packages/shared-python/shared/services/retrieval/nav/persisted_score_load.py +++ b/packages/shared-python/shared/services/retrieval/scoring/persisted_score_load.py @@ -6,7 +6,7 @@ from collections.abc import Mapping, Sequence from typing import Any -from shared.services.retrieval.nav.knowhere_hybrid import PersistedBm25Stats +from shared.services.retrieval.scoring.knowhere_hybrid import PersistedBm25Stats def average_idf_from_unit_dfs( diff --git a/packages/shared-python/shared/services/retrieval/scoring/score_units.py b/packages/shared-python/shared/services/retrieval/scoring/score_units.py new file mode 100644 index 00000000..e9c05b0a --- /dev/null +++ b/packages/shared-python/shared/services/retrieval/scoring/score_units.py @@ -0,0 +1,188 @@ +"""Build persisted map-unit scoring rows from a hierarchy tool space.""" + +from __future__ import annotations + +from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, cast + +from shared.services.retrieval.scoring.knowhere_hybrid import ( + build_content_search_text, + build_path_search_text, + build_term_search_text, +) + +def _children_ids(ts: Any, section_id: str, doc_id: str) -> List[str]: + children_fn = getattr(ts, "_children_for_section_path", None) + if not callable(children_fn): + st = ts.get_structure(section_id) + rows = st.get("children") or [] + return [ + str(r.get("section_id") or "").strip() for r in rows if r.get("section_id") + ] + rows = cast(Sequence[Any], children_fn(section_id, doc_id)) + return [str(r.get("section_id") or "").strip() for r in rows if r.get("section_id")] + + +def _line_content(ts: Any, section_id: str, doc_id: str) -> str: + """Raw line text for a section node (no truncation).""" + idx = getattr(ts, "_idx", None) + b = getattr(idx, "_bundles", {}).get(doc_id) if idx is not None else None + if b is None: + path_fn = getattr(ts, "path_titles", None) + if callable(path_fn): + path = str(path_fn(section_id, doc_id) or "").strip() + return path.rsplit(" / ", 1)[-1] if path else "" + st = ts.get_structure(section_id) + return str(st.get("preview") or "").strip() + loc = getattr(idx, "_node_to_doc_line", {}).get(section_id) + if not loc: + return "" + _doc, line_idx = loc + if line_idx < 0 or line_idx >= len(b.lines): + return "" + return str(b.lines[line_idx].content or "").strip() + + +def _ancestor_path_titles(ts: Any, section_id: str, doc_id: str) -> str: + idx = getattr(ts, "_idx", None) + if idx is None: + # Provider-backed spaces expose the title chain directly; without this + # the path channel would score every unit as empty. + path_fn = getattr(ts, "path_titles", None) + return str(path_fn(section_id, doc_id) or "") if callable(path_fn) else "" + try: + ancestors = list(idx.ancestor_line_node_ids(section_id)) + except Exception: + ancestors = [] + titles: List[str] = [] + for aid in reversed(ancestors): + if not str(aid).startswith(f"{doc_id}:"): + continue + titles.append(_line_content(ts, aid, doc_id)) + titles.append(_line_content(ts, section_id, doc_id)) + return " / ".join(t for t in titles if t) + + +def _self_only_text(ts: Any, section_id: str, doc_id: str) -> Tuple[str, bool]: + """Return (self_text, has_interstitial_body). + + Interstitial means self_only span contains content beyond the heading line + itself (structural: more than one line/chunk in the self span). + """ + self_fn = getattr(ts, "materialize_self_only_chunks", None) + if not callable(self_fn): + return "", False + chunks = list(cast(Sequence[Any], self_fn(section_id, doc_id) or [])) + if not chunks: + return "", False + texts = [str(getattr(c, "text", "") or "").strip() for c in chunks] + texts = [t for t in texts if t] + if not texts: + return "", False + # Structural interstitial: self span covers more than the node heading line. + has_interstitial = len(chunks) > 1 + return "\n".join(texts), has_interstitial + + +def _section_body_text(ts: Any, section_id: str, doc_id: str) -> str: + """Heading + lines until first structural child (leaf body / parent self span).""" + text, _ = _self_only_text(ts, section_id, doc_id) + if text: + return text + return _line_content(ts, section_id, doc_id) + + +def _walk_tree( + ts: Any, + doc_id: str, + root_ids: Sequence[str], +) -> Tuple[Dict[str, List[str]], Set[str], Dict[str, str]]: + """Return children map, leaf ids, and title map for reachable nodes.""" + children_map: Dict[str, List[str]] = {} + titles: Dict[str, str] = {} + leaves: Set[str] = set() + seen: Set[str] = set() + + def walk(sid: str) -> None: + if not sid or sid in seen: + return + seen.add(sid) + titles[sid] = _line_content(ts, sid, doc_id) + kids = [c for c in _children_ids(ts, sid, doc_id) if c] + children_map[sid] = kids + if not kids: + leaves.add(sid) + return + for kid in kids: + walk(kid) + + for rid in root_ids: + walk(rid) + return children_map, leaves, titles + + +def build_score_units( + ts: Any, doc_id: str, root_ids: Optional[Sequence[str]] = None +) -> List[dict]: + """Build leaf (+ interstitial self_only) units for hybrid scoring.""" + if root_ids is None: + root_ids = list(ts.sections_for_doc(doc_id)) + children_map, leaves, titles = _walk_tree(ts, doc_id, root_ids) + units: List[dict] = [] + seen_unit_ids: Set[str] = set() + + for leaf_id in sorted(leaves): + content = _section_body_text(ts, leaf_id, doc_id) or ( + titles.get(leaf_id) or _line_content(ts, leaf_id, doc_id) + ) + path_text = _ancestor_path_titles(ts, leaf_id, doc_id) + unit_id = leaf_id + if unit_id in seen_unit_ids: + continue + seen_unit_ids.add(unit_id) + title = titles.get(leaf_id) or _line_content(ts, leaf_id, doc_id) + units.append( + { + "chunk_id": unit_id, + "section_id": leaf_id, + "kind": "leaf", + "content": content, + "path_text": path_text, + "path_search_text": build_path_search_text( + section_path=path_text, section_title=title or content + ), + "content_search_text": build_content_search_text(content), + "term_search_text": build_term_search_text( + content, path_text=path_text + ), + } + ) + + # Parents with interstitial self body. + for sid, kids in children_map.items(): + if not kids: + continue + self_text, has_interstitial = _self_only_text(ts, sid, doc_id) + if not has_interstitial or not self_text: + continue + unit_id = f"{sid}__self" + if unit_id in seen_unit_ids: + continue + seen_unit_ids.add(unit_id) + path_text = _ancestor_path_titles(ts, sid, doc_id) + units.append( + { + "chunk_id": unit_id, + "section_id": sid, + "kind": "self_only", + "content": self_text, + "path_text": path_text, + "path_search_text": build_path_search_text( + section_path=path_text, section_title=titles.get(sid) or "" + ), + "content_search_text": build_content_search_text(self_text), + "term_search_text": build_term_search_text( + self_text, path_text=path_text + ), + } + ) + return units diff --git a/packages/shared-python/shared/services/retrieval/search/map_unit_discovery.py b/packages/shared-python/shared/services/retrieval/search/map_unit_discovery.py index 68e27402..b2a72978 100644 --- a/packages/shared-python/shared/services/retrieval/search/map_unit_discovery.py +++ b/packages/shared-python/shared/services/retrieval/search/map_unit_discovery.py @@ -1,7 +1,6 @@ """Classic-route discovery via the persisted map-unit BM25 scorer. -Replaces the retired chunk-level 3-channel SQL scan. Scoring uses the same -``score_persisted_corpus_many`` formula as map-nav (path + content only). +Scoring uses ``score_persisted_corpus_many`` over path + content only. ``chunk_types`` is optional: omitted means score every in-scope unit. When the request is image/table only, ``has_image`` / ``has_table`` (written at @@ -31,14 +30,14 @@ iter_connected_target_ids, normalize_chunk_type, ) -from shared.services.retrieval.nav.knowhere_hybrid import ( +from shared.services.retrieval.scoring.knowhere_hybrid import ( MAP_UNIT_INDEX_FORMAT_VERSION, PersistedScoreCorpus, PersistedScoreUnit, score_persisted_corpus_many, tokenize_query_for_ranker, ) -from shared.services.retrieval.nav.persisted_score_load import ( +from shared.services.retrieval.scoring.persisted_score_load import ( build_channel_bm25_stats, combine_average_idf, ) @@ -508,26 +507,11 @@ async def map_unit_discovery( ) except Exception as exc: logger.warning("retrieval index readiness publish failed: %s", exc) - logger.warning( - "retrieval map index incomplete user_id=%s namespace=%s " - "expected_revisions=%d indexed_revisions=%d fallback=legacy_fts", - user_id, - namespace, - len(expected_revisions), - len(index_parts), - ) - return await _legacy_chunk_discovery( - db, - user_id=user_id, - namespace=namespace, - query=query, - top_k=top_k, - exclude_document_ids=exclude_document_ids, - exclude_sections=exclude_sections, - chunk_types=chunk_types, - signal_paths=signal_paths or [], - filter_mode=filter_mode, - revision_pins=revision_pins, + raise RuntimeError( + "retrieval map-unit index is incomplete or incompatible " + f"(user_id={user_id} namespace={namespace} " + f"expected_revisions={len(expected_revisions)} " + f"indexed_revisions={len(index_parts)})" ) if has_incomplete_index_statistics: logger.warning( @@ -701,103 +685,6 @@ async def map_unit_discovery( ) -async def _legacy_chunk_discovery( - db: AsyncSession, - *, - user_id: str, - namespace: str, - query: str, - top_k: int, - exclude_document_ids: list[str], - exclude_sections: list[dict[str, str]], - chunk_types: set[str] | None, - signal_paths: list[str], - filter_mode: str, - revision_pins: Mapping[str, str] | None, -) -> DiscoveryResult: - """Bounded lexical fallback used while a serving index is incomplete.""" - clauses = [ - "d.user_id = :user_id", - "d.namespace = :namespace", - "d.status = 'active'", - ] - params: dict[str, Any] = { - "user_id": user_id, - "namespace": namespace, - "query": query, - "limit": max(1, int(top_k)), - } - if revision_pins is None: - clauses.append("d.current_job_result_id = dc.job_result_id") - else: - pairs = [ - (str(document_id), str(job_result_id)) - for document_id, job_result_id in revision_pins.items() - ] - if not pairs: - return DiscoveryResult(status="discovery_done", payload={"fused_rows": []}) - placeholders = [] - for index, (document_id, job_result_id) in enumerate(pairs): - document_key = f"_legacy_doc_{index}" - revision_key = f"_legacy_revision_{index}" - placeholders.append(f"(:{document_key}, :{revision_key})") - params[document_key] = document_id - params[revision_key] = job_result_id - clauses.append(f"(dc.document_id, dc.job_result_id) IN ({', '.join(placeholders)})") - if exclude_document_ids: - clauses.append("d.document_id <> ALL(:excluded_doc_ids)") - params["excluded_doc_ids"] = exclude_document_ids - if chunk_types: - type_keys = [] - for index, chunk_type in enumerate(sorted(chunk_types)): - key = f"_legacy_type_{index}" - type_keys.append(f":{key}") - params[key] = chunk_type - clauses.append(f"LOWER(dc.chunk_type) IN ({', '.join(type_keys)})") - if signal_paths: - signal_parts = [] - for index, signal in enumerate(signal_paths): - key = f"_legacy_signal_{index}" - signal_parts.append("LOWER(COALESCE(ds.section_path, '')) LIKE :" + key) - params[key] = f"%{signal.lower()}%" - combined = " OR ".join(signal_parts) - clauses.append(f"({combined})" if filter_mode == "keep" else f"NOT ({combined})") - for index, item in enumerate(exclude_sections): - document_id = str(item.get("document_id") or "").strip() - section_path = str(item.get("section_path") or "").strip() - if not document_id or not section_path: - continue - doc_key = f"_legacy_exclude_doc_{index}" - path_key = f"_legacy_exclude_path_{index}" - params[doc_key] = document_id - params[path_key] = section_path - clauses.append( - "NOT (dc.document_id = :" + doc_key + " AND (" - "COALESCE(ds.section_path, '') = :" + path_key + " OR " - "POSITION(:" + path_key + " || ' / ' IN COALESCE(ds.section_path, '')) = 1))" - ) - where_sql = " AND ".join(clauses) - statement = text( - "SELECT dc.chunk_id, dc.document_id, dc.section_id, dc.chunk_type, " - "dc.content, dc.source_chunk_path, dc.file_path, dc.chunk_metadata, " - "dc.job_result_id, dc.sort_order, ds.section_path, d.source_file_name, " - "jr.job_id, GREATEST(ts_rank_cd(dc.path_search_tsv, plainto_tsquery('simple', :query)), " - "2 * ts_rank_cd(dc.content_search_tsv, plainto_tsquery('simple', :query))) AS score " - "FROM document_chunks dc JOIN documents d ON d.document_id = dc.document_id " - "LEFT JOIN document_sections ds ON ds.section_id = dc.section_id " - "LEFT JOIN job_results jr ON jr.id = dc.job_result_id " - f"WHERE {where_sql} AND (dc.path_search_tsv @@ plainto_tsquery('simple', :query) " - "OR dc.content_search_tsv @@ plainto_tsquery('simple', :query) " - "OR LOWER(COALESCE(dc.term_search_text, '')) LIKE LOWER(:term_query)) " - "ORDER BY score DESC, dc.sort_order, dc.chunk_id LIMIT :limit" - ) - params["term_query"] = f"%{query}%" - rows = [dict(row._mapping) for row in (await db.execute(statement, params)).all()] - if rows: - normalize_row_scores(rows, source_field="score", target_field="discovery_score", default=0.5) - return DiscoveryResult(status="discovery_done", payload={"fused_rows": rows}) - - def _as_metadata_dict(value: object) -> dict[str, Any]: if isinstance(value, dict): return value diff --git a/packages/shared-python/shared/services/retrieval/settings.py b/packages/shared-python/shared/services/retrieval/settings.py index 7e7df316..4dd3130b 100644 --- a/packages/shared-python/shared/services/retrieval/settings.py +++ b/packages/shared-python/shared/services/retrieval/settings.py @@ -6,9 +6,8 @@ RRF_K = 60 DEFAULT_TOP_K = 10 -# Final evidence / tool-observation text budget (characters). Shared by map-nav -# evidence packing (``nav_config.MAPNAV_EVIDENCE_CHARS``) and agent tool-loop -# harness caps (``ToolBudget.max_chars`` in ``agent_explore/episode.py``). +# Final evidence / tool-observation text budget (characters). Used by +# agent tool-loop harness caps (``ToolBudget.max_chars``). EVIDENCE_TEXT_CHAR_BUDGET = 12_000 VALID_CHUNK_TYPES: set[str] = {"text", "image", "table", "page"} diff --git a/packages/shared-python/shared/services/retrieval/trace/__init__.py b/packages/shared-python/shared/services/retrieval/trace/__init__.py index 54152432..657a5ebe 100644 --- a/packages/shared-python/shared/services/retrieval/trace/__init__.py +++ b/packages/shared-python/shared/services/retrieval/trace/__init__.py @@ -1,21 +1,9 @@ """Retrieval decision-trace package (replaces agentic/core trace types).""" -from shared.services.retrieval.trace.mapnav import ( - build_decision_trace, - episode_selected_doc_ids, - episode_selected_paths, - episode_token_count, - episode_workflow_plan, -) from shared.services.retrieval.trace.recorder import TraceRecorder from shared.services.retrieval.trace.types import DecisionTraceStep __all__ = [ "DecisionTraceStep", "TraceRecorder", - "build_decision_trace", - "episode_workflow_plan", - "episode_selected_paths", - "episode_selected_doc_ids", - "episode_token_count", ] diff --git a/packages/shared-python/shared/services/retrieval/trace/recorder.py b/packages/shared-python/shared/services/retrieval/trace/recorder.py index 79d5cea7..8b5156a3 100644 --- a/packages/shared-python/shared/services/retrieval/trace/recorder.py +++ b/packages/shared-python/shared/services/retrieval/trace/recorder.py @@ -15,7 +15,6 @@ from loguru import logger from sqlalchemy.ext.asyncio import AsyncSession -from shared.services.retrieval.nav_config import MAPNAV_MODEL from shared.services.retrieval.settings import DEFAULT_TOP_K from shared.services.retrieval.trace.types import DecisionTraceStep @@ -47,7 +46,7 @@ def __init__( policy_name: str = "llm_policy_v1", config: Any = None, ) -> None: - del config # legacy AgentRunConfig; ignored on map-nav path + del config # unused AgentRunConfig leftover; ignored self._db = db self._run_id = f"aret_{uuid4().hex[:12]}" self._user_id = user_id @@ -236,7 +235,7 @@ async def complete( "router": router_used, "step_count": len(self._steps), "final_doc_ids": doc_ids_in_result, - "model_name": model_name or MAPNAV_MODEL, + "model_name": model_name or "unknown", } if selected_paths is not None: provenance["selected_paths"] = selected_paths diff --git a/packages/shared-python/shared/tests/test_agent_explore_harness.py b/packages/shared-python/shared/tests/test_agent_explore_harness.py index f005de2d..7b9740ce 100644 --- a/packages/shared-python/shared/tests/test_agent_explore_harness.py +++ b/packages/shared-python/shared/tests/test_agent_explore_harness.py @@ -145,8 +145,8 @@ def _clean_harness_env(monkeypatch: pytest.MonkeyPatch) -> None: monkeypatch.delenv(_HARNESS_ENV, raising=False) -def test_resolve_harness_name_defaults_to_openai() -> None: - assert resolve_harness_name() == "openai" +def test_resolve_harness_name_defaults_to_cursor_sdk() -> None: + assert resolve_harness_name() == "cursor_sdk" def test_resolve_harness_name_reads_env(monkeypatch: pytest.MonkeyPatch) -> None: @@ -158,7 +158,7 @@ def test_resolve_harness_name_unknown_value_falls_back_to_default( monkeypatch: pytest.MonkeyPatch, ) -> None: monkeypatch.setenv(_HARNESS_ENV, "not_a_real_harness") - assert resolve_harness_name() == "openai" + assert resolve_harness_name() == "cursor_sdk" def test_resolve_harness_name_is_case_insensitive(monkeypatch: pytest.MonkeyPatch) -> None: @@ -166,11 +166,11 @@ def test_resolve_harness_name_is_case_insensitive(monkeypatch: pytest.MonkeyPatc assert resolve_harness_name() == "cursor_sdk" -def test_resolve_harness_default_builds_openai_harness() -> None: - from shared.services.retrieval.agent_explore.harness.openai_harness import OpenAIHarness +def test_resolve_harness_default_builds_cursor_harness() -> None: + from shared.services.retrieval.agent_explore.harness.cursor_harness import CursorHarness harness = resolve_harness() - assert isinstance(harness, OpenAIHarness) + assert isinstance(harness, CursorHarness) assert isinstance(harness, Harness) diff --git a/packages/shared-python/shared/tests/test_asset_inline.py b/packages/shared-python/shared/tests/test_asset_inline.py index a59652f0..d8345c24 100644 --- a/packages/shared-python/shared/tests/test_asset_inline.py +++ b/packages/shared-python/shared/tests/test_asset_inline.py @@ -10,8 +10,8 @@ from shared.services.retrieval.hydration.result_assembly import ( assemble_retrieval_results, ) -from shared.services.retrieval.nav.nav_hierarchy import ProviderToolSpace -from shared.services.retrieval.nav.nav_knowhere import ( +from shared.services.retrieval.scoring.hierarchy import ProviderToolSpace +from shared.services.retrieval.scoring.knowhere_provider import ( KnowhereProvider, SectionRow, UnitRow, diff --git a/packages/shared-python/shared/tests/test_knowhere_hybrid_tokenize.py b/packages/shared-python/shared/tests/test_knowhere_hybrid_tokenize.py index 2d4b96e1..8b559ebb 100644 --- a/packages/shared-python/shared/tests/test_knowhere_hybrid_tokenize.py +++ b/packages/shared-python/shared/tests/test_knowhere_hybrid_tokenize.py @@ -2,7 +2,7 @@ from __future__ import annotations -from shared.services.retrieval.nav.knowhere_hybrid import ( +from shared.services.retrieval.scoring.knowhere_hybrid import ( MAP_UNIT_INDEX_FORMAT_VERSION, build_content_search_text, build_path_search_text, diff --git a/pyproject.toml b/pyproject.toml index 19876076..b764a83e 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -47,7 +47,7 @@ exclude = [ "packages/shared-python/build", "packages/shared-python/dist", "packages/shared-python/shared/tests", - "packages/shared-python/shared/services/retrieval/nav", + "deprecated", ] executionEnvironments = [ { root = "apps/api", extraPaths = ["packages/shared-python"] }, @@ -63,6 +63,7 @@ src = [ "apps/worker", "packages/shared-python", ] +exclude = ["deprecated"] [tool.ruff.lint] select = ["E", "F"] diff --git a/pytest.ini b/pytest.ini index e83f7c02..cd7e4782 100644 --- a/pytest.ini +++ b/pytest.ini @@ -1,4 +1,6 @@ [pytest] +norecursedirs = deprecated .* +addopts = --ignore=deprecated asyncio_mode = auto asyncio_default_fixture_loop_scope = function filterwarnings = diff --git a/uv.lock b/uv.lock index 4c1be47b..2e598298 100644 --- a/uv.lock +++ b/uv.lock @@ -1413,6 +1413,7 @@ dependencies = [ { name = "aiohttp" }, { name = "alembic" }, { name = "celery" }, + { name = "cursor-sdk" }, { name = "fastapi" }, { name = "httpx" }, { name = "knowhere-shared" }, @@ -1447,6 +1448,7 @@ requires-dist = [ { name = "aiohttp", specifier = "==3.13.4" }, { name = "alembic", specifier = "==1.13.1" }, { name = "celery", specifier = "==5.5.3" }, + { name = "cursor-sdk", specifier = ">=1.0.31" }, { name = "fastapi", specifier = "==0.135.1" }, { name = "httpx", specifier = "==0.28.1" }, { name = "knowhere-shared", editable = "packages/shared-python" }, From b6a95a8fe84d633b8335412778953f16dc67cfbe Mon Sep 17 00:00:00 2001 From: suguanYang Date: Tue, 8 Sep 2026 21:30:23 +0800 Subject: [PATCH 12/15] Potential fix for pull request finding 'CodeQL / Implicit string concatenation in a list' Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com> --- apps/worker/scripts/run_agentic_router_eval.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/apps/worker/scripts/run_agentic_router_eval.py b/apps/worker/scripts/run_agentic_router_eval.py index 752ed091..328503b4 100644 --- a/apps/worker/scripts/run_agentic_router_eval.py +++ b/apps/worker/scripts/run_agentic_router_eval.py @@ -206,9 +206,9 @@ def _p50(values: list[int]) -> int | None: f"- agent_explore p50: {_p50(agent_ms)} ms ({len(agent_ms)} runs)\n", "\n## Notes\n", "- Runs bypass Redis retrieval cache (direct ``run_retrieval_route``).\n", - "- ``kw hit`` = expected keywords found in ``evidence_text`` " + "- ``kw hit`` = expected keywords found in ``evidence_text`` " + "(proxy for recall quality, not a full answer judge).\n", - "- Phase 0 ad-hoc queries are separate; this set is the 8 questions " + "- Phase 0 ad-hoc queries are separate; this set is the 8 questions " + "from ``zh_档案知识库测试样例.docx``.\n", ] ) From 7a0a51b8468d90d6142e6f8f78fffbf9f10434f7 Mon Sep 17 00:00:00 2001 From: suguanYang Date: Tue, 8 Sep 2026 21:31:12 +0800 Subject: [PATCH 13/15] Potential fix for pull request finding 'CodeQL / Variable defined multiple times' Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com> --- .../services/retrieval/agent_explore/harness/openai_harness.py | 1 - 1 file changed, 1 deletion(-) diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py index 2d48f505..edad393b 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py @@ -190,7 +190,6 @@ async def run_episode( ] steps: list[AgentStep] = [] - stop_reason = "finished" result_refs: list[dict[str, Any]] = [] result_notes = "" # Refs from every corpus.read/corpus.assets call this episode, in call From e658657d0b2c15c08d69b140211e7c1aa56fb69f Mon Sep 17 00:00:00 2001 From: suguanYang Date: Tue, 8 Sep 2026 21:50:34 +0800 Subject: [PATCH 14/15] fix: clear CodeQL alerts on agent_tools tool registration Addresses the remaining code-scanning comments from the main->staging PR #396 (alerts 417-419 were already fixed on main by b6a95a8f/7a0a51b8): - harness/base.py: replace the ineffectual "..." ellipsis placeholder in the Harness Protocol with "raise NotImplementedError", matching the convention used by other Protocols in this repo (CodeQL: statement has no effect). - agent_tools/__init__.py: perform the tools side-effect import (which registers every corpus.* tool via @register_tool) here, so any consumer importing a name from this package is guaranteed a fully populated REGISTRY; list "_tools" in __all__ as a deliberate re-export. - drop the now-redundant per-consumer side-effect imports of "agent_tools.tools" in dynamic_tools.py, cursor_harness.py, and openai_harness.py (CodeQL: unused import). Removing them outright would have broken tool registration - REGISTRY.all() would be empty. --- apps/api/app/mcp/dynamic_tools.py | 1 - .../retrieval/agent_explore/harness/base.py | 2 +- .../agent_explore/harness/cursor_harness.py | 1 - .../agent_explore/harness/openai_harness.py | 1 - .../services/retrieval/agent_tools/__init__.py | 14 +++++++++++++- 5 files changed, 14 insertions(+), 5 deletions(-) diff --git a/apps/api/app/mcp/dynamic_tools.py b/apps/api/app/mcp/dynamic_tools.py index 3a52b2fb..efb842f7 100644 --- a/apps/api/app/mcp/dynamic_tools.py +++ b/apps/api/app/mcp/dynamic_tools.py @@ -24,7 +24,6 @@ from sqlalchemy.ext.asyncio import AsyncSession from shared.services.retrieval.agent_tools import REGISTRY, ToolContext, ToolSpec -from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 DbFactory = Callable[[], AsyncContextManager[AsyncSession]] diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/base.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/base.py index 45c236f7..4bab470e 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/base.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/base.py @@ -39,4 +39,4 @@ async def run_episode( so concurrent tool calls (a real Cursor SDK behavior, not just a theoretical one — see ``harness/cursor_harness.py``) are always safe. """ - ... + raise NotImplementedError diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py index 0d84b566..6678be43 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/cursor_harness.py @@ -93,7 +93,6 @@ ToolResult, load_corpus_schema_text, ) -from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 # Grace period for the underlying agent run to actually stop, after a # best-effort run.cancel() following a wall_clock timeout, before this diff --git a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py index edad393b..80fd5716 100644 --- a/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py +++ b/packages/shared-python/shared/services/retrieval/agent_explore/harness/openai_harness.py @@ -77,7 +77,6 @@ ) from shared.services.retrieval.agent_explore.types import AgentStep, EpisodeResult from shared.services.retrieval.agent_tools import REGISTRY, ToolBudget, load_corpus_schema_text -from shared.services.retrieval.agent_tools import tools as _agent_tools_registered # noqa: F401 # A tool-role message is kept in full for the turn it was produced plus this # many additional turns, then collapsed to a placeholder — see module diff --git a/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py b/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py index 9f5b4284..5583243f 100644 --- a/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py +++ b/packages/shared-python/shared/services/retrieval/agent_tools/__init__.py @@ -9,7 +9,9 @@ The same ``REGISTRY`` is meant to be consumed by two harnesses (Phase 3): the API ``/mcp`` server (Cursor/Codex/Claude) and the in-process ``agent_explore`` tool-loop. Importing ``agent_tools.tools`` registers every -tool as a side effect. +tool as a side effect; this package performs that import itself (below), so +any consumer importing a name here (e.g. ``REGISTRY``) is guaranteed a fully +populated registry. """ from __future__ import annotations @@ -26,7 +28,17 @@ ) from shared.services.retrieval.agent_tools.schema_doc import load_corpus_schema_text +# Register every ``corpus.*`` tool into ``REGISTRY`` as an import side effect: +# each module under ``tools/`` calls ``@register_tool`` at import time. Kept +# here — not in ``registry.py``, which the tool modules import and would +# therefore create a cycle — so consumers importing any name from this package +# no longer need their own side-effect import of ``tools``. ``_tools`` is +# intentionally never referenced (listed in ``__all__`` as a deliberate +# re-export so tooling does not flag it as unused). +from shared.services.retrieval.agent_tools import tools as _tools + __all__ = [ + "_tools", "REGISTRY", "ToolBudget", "ToolContext", From b3ef26b7208891d74a06002ff00429187297c628 Mon Sep 17 00:00:00 2001 From: cqboy1993 <167045138+EricNGOntos@users.noreply.github.com> Date: Tue, 8 Sep 2026 21:56:40 +0800 Subject: [PATCH 15/15] docs: update Knowhere 2.0 retrieval story (#398) --- README.md | 15 +++++++++------ .../assets/step-2-agent-neutral-retrieval.png | Bin 0 -> 1113109 bytes 2 files changed, 9 insertions(+), 6 deletions(-) create mode 100644 docs/assets/step-2-agent-neutral-retrieval.png diff --git a/README.md b/README.md index 1b961d4f..a9fdf7fc 100644 --- a/README.md +++ b/README.md @@ -37,7 +37,7 @@ It ingests unstructured documents and produces persistent, navigable memory: parsing, hierarchy reconstruction, multi-modal structuring, and graph construction in a single pipeline. Every result stays connected to its document, section, source pages, and related assets, making the output a natural fit for *Agentic RAG*, *vector-based RAG*, or any LLM workflow. -Knowhere supports complementary **Vision and Text tracks**. Text-native documents retain precise extracted structure, while complex PDFs and PowerPoint files can be understood directly as pages by frontier vision models. Both tracks converge into the same memory schema, hierarchy, retrieval engine, and citation model. +Knowhere 2.0 supports complementary **Vision and Text tracks**. Text-native documents retain precise extracted structure, while complex PDFs and PowerPoint files can be understood directly as pages by frontier vision models. Both tracks converge into the same memory schema, hierarchy, retrieval engine, and citation model. > [!NOTE] > **Get started in seconds with Knowhere Cloud.** @@ -45,6 +45,7 @@ Knowhere supports complementary **Vision and Text tracks**. Text-native document ## 📢 News +- **September 8, 2026**: 🧭 **Introducing agent-native Retrieval 2.0.** MapNav has evolved from a fixed navigation workflow into a corpus-native foundation for agents. Knowhere provides a unified schema, hierarchy-aware tools, and resolvable evidence references; the agent decides how to search, traverse, read, and cite. The same foundation powers built-in retrieval and external agents through MCP. - **September 2026**: 👁️ **Introducing dual-track Document Parsing 2.0.** Vision Page and Text Track now converge into one hierarchy-native memory schema for retrieval, understanding, and citation. - **June 1, 2026**: 📚 **Knowhere now supports ultra-long PDFs and atlas-style documents.** The parsing pipeline can process long-form PDFs with hundreds of pages (for example, 300, 500, or more) and route technical atlases or drawing collections through a dedicated layout-aware parser. - **May 7, 2026**: 🚀 **Knowhere is now Open Source!** We have open-sourced our entire stack for document ingestion, parsing, and agentic RAG. You can now self-host the full platform using [knowhere-self-hosted](https://github.com/Ontos-AI/knowhere-self-hosted). Check out our [Contribution Guide](CONTRIBUTING.md) to get involved! @@ -78,13 +79,15 @@ Knowhere runs in two steps: build memory from documents, then let agents retriev ### Step 2: Agentic Retrieval +Knowhere provides the document-memory substrate; the agent decides how to explore it. +

- Step 2: Agentic Retrieval + Any agent can explore Knowhere Memory through one neutral corpus tool contract

-- **Discover**: Fuse path, content, term, summary, and entity signals for broad first-pass coverage. -- **Navigate**: Use hierarchy-aware MapNav to move from document overviews into the most relevant sections and evidence. -- **Cite Evidence**: Return traceable results with source document, section, source pages, and linked assets. +- **Provide the substrate**: Knowhere exposes one corpus schema and tools for document outlines, structural filters, exact search, fuzzy recall, full reading, assets, and cross-document relationships. +- **Let the agent explore**: Instead of forcing every query through a fixed navigation pipeline, the agent chooses which tools to call, in what order, and how deeply to traverse. +- **Stay agent-neutral**: The same corpus and evidence contract works across built-in agents, MCP clients, models, and orchestration frameworks. Whichever agent explores the memory, Knowhere resolves its references into traceable documents, sections, pages, and linked assets. ## FAQ @@ -141,7 +144,7 @@ Agents using Knowhere outperform those working from raw documents, Markitdown, U - **Vision Page Understanding**: Frontier vision models make complex PDF and PowerPoint content recallable without requiring perfect element-by-element OCR or layout reconstruction. - **Hierarchy-native Memory**: Section nodes preserve document paths, page ranges, summaries, entities, and linked assets instead of returning disconnected chunks. - **Cross-document Memory Graph**: Page-derived typed entities and keywords connect related documents across a namespace. -- **Agentic Retrieval**: MapNav navigates document hierarchies, while classic retrieval combines path, content, and term channels through RRF. +- **Agent-native Retrieval**: Built-in and MCP-connected agents explore the same corpus schema and hierarchy-aware tools; classic retrieval remains available for deterministic top-K search. - **Page-grounded Citations**: Results retain source documents, section paths, page numbers, and rendered visual evidence. ## Supported Formats diff --git a/docs/assets/step-2-agent-neutral-retrieval.png b/docs/assets/step-2-agent-neutral-retrieval.png new file mode 100644 index 0000000000000000000000000000000000000000..21e075d671e56539646243b1382f6e35d5107dff GIT binary patch literal 1113109 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 <=w8Gx*| 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

0|l_HR))cn$Z@_HQ?qv$_dV`_akr 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 z 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 z%0A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 z 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ͽ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

%L$ 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�#m$0F3 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�aTlZ4swN(Aio)oM80H~_ ze>x6CnKq!9%t|R}(WQ7M3#0S+l~aj?83T3~v;r8-kuK(LM5|G*w;<6JfzG6kj1TAS zAz9uKCZ!fmLMBmsx@=QdSMi{@I71F5EhtG1^(B86op_Y63#l>t;VdT{awd%2`zlrh zQJLNF6s;TyX4c)@Cl}d^tdQQpfJW^JSwPx^l}^%Cl~!V{san5b${;8+%xd2?LRI%Z z0Cg~oH_CNlb=F$Rq+dE;7c#2hk{?8xBFA$ZF)?r^kaOaZY7_UM_;;(7Kdq-|_eR^9 zY81?rN}E+G)c71Pf{yqsHpb2Z7+*amUC~ITocE%(|7z?s4?g0^?~yU3Q#%FnHwdJ< zlWKJ42cEh!vM67w1rSs1M>FU<-xddfa3xUVEJWNH{GjZT&o^;e%fZrDi-MB&+ zo|LPU>~tEKFx@V_B-CTR`m*w34!=1o!|ixeya|-v)h#6zlORW5kyf?j91WROoynkQ zj9!AQ?N@6hArCbZ!2&9>uc{|k@_i%@pi8vJTiow=_Nb3T4k1JhK3%M`C+fi>=QV^7 zJd~OvQ>YXG*&RqZQAxxd88tNf>&A}oMg&mba!w))C))gG1eDgZ<6Q;+Dt)yhst%r^#NBT6kCuUj_GDmbo zTLL`}tq|Jpri0w3uO%C<>SmgA`jNtCwFui`>fwYo<*vCmr8%8(*dwE|Hj$~)(o$%| z*@eRsYnoF18Nf~-08$s`u6$*rQ$|%aZD-uiY2jc(!jY_rt-g9wEUZ$j zy?C(WZsOVKyY5*%HJ^wrgWLri@=ZKcJ-Q@<`nMz-Zb+y{fb(7*#o4deIf+i@%}8 zLbU=OLrGJl*~Wn}DY8?|CHYC0uYMBt4>{&@+3b-x8-6BaK>cQdCs1@5yq=~OA@f@9YMlS@claSC8sTJRBMolsy&v8U9^AE)m`{3oQ5#G>e^ zBEV2tiN~maL&nFI^n^`xC3vBHNQB89jm|K$k|sKZp)^~nW4Z*1Zm?7;yh{&`DNrR} zO`C1ho$e|z8r)ShQTbGjIDF`VvCddwrg|ne@En6U^%oAb-}${D*At0YG*F;Q%wN?h zS@8>xY%7R<>zoOAIBwcVGeL?}T`8x0{nkR3?nt)^8CE4MC4Su{X#A#!YNBJOP?q$N zX=#mocUsPHKnsRAZ1kO}wL!$H;*i}}iDr7laNCqHnf3QRK(8n=#P2$0OO-_qDARCL za5lc$v}bCC4f2*9{Pwsu4jDp`D_ioy>_R3VzjOvQAHGLd6{1xdQBFb4zn9RpGxoWs z@vK`CtBk_5B|A|(Bg)paVf~JRA`$By@d z;RObUQ!V=EF~8-c*{CIjyzAP4YchkH22-aR>At*`--%&(;&WDp-9~LzIg2fyY&Wnv ze>xxQp_|D>?JV=+O$#S|PvdxHDRo#q#%_6kfON(_v+;eDA~1p~bCoF16JfVt_emag z9M?L`z14^F1Y~j0)dLBA!fkgNh3GNqc>QYNo*G&B9GWTXuyQVzvt?BZ4|hR{QEzX` z-cDo&7+SC7Bb%#x^!j>VlNi+G)`-g6+1q>UY2$3+Dd34xv;|a&OuG5kQzSk};r9eS zRTbZnu{dI?>gjE?eHNamGKcXCxw<&qDkJMH6)!BCRVL1B{f$l*h53wz3Q^ZG8LuQvXmc;XM zY@J)Ue;)Vb^N4(&r{(A1qs&F4;2>A?32~={yE6B0-`Q)pz@vlomVA^l9U{JDC30LH z((@!OC&-}BiMMj2e@rO`>p3l}hI3oys$*0A^7$xGl^nnbu8PI*+;~L`NhDZ1GVGyq z%m|{qX94tfE#NYR*&o1;KoYrE?$o=yhYPAbaBB&nGIkqt1{9@|33bmT594Jy2$6R` zbe=}qy|65BTXKGGkT}kD9Z}<)4<_dxd{f2a!pWf-uF~HM&o{-K;MLo-9D>{v4@nP% zEggwe$yX%y90DHBRi|E^gtouIq}q;zOpNUa_|3dS!SIiSR2w)s%FG%pp^SG<8ktko$p(bYIXoPRO*;$(aF?UH4%9b|f043F?;g_!m_UyonCK z3dzI1n7%eBl9Vf>7${##?J0#WX-umxkjtl^(J=Zl7V`s1l~c<_XK8^-^=Lc@|Jmxy zy(qt2htO%C7OQJooFm%PVfc|1TdqYm@F70!S z1h-u3hdd&S$teL04<$;c`?Ra0Ob?UTV=MCOp1b$ZLt3KN&cLBSJf}l=ePQb1XPg|7EygU zR2dG)!QrvgD6|I0!lD8xSGrTNH{cMHlH8OG{bB29)l%3TfYTKDyrUd3R}90sZ)eg- ziJqWXv|~ng2>vUpd7RYcEKs-m>P^9)vW*9qQ6;IOJw3yK4CAG`3(cUQ%Vk{84H{1( zG2J^-a(qba9z+)^A^|5y>A|jdee#N$>4c(s0eddy6jkNZ!sqNjQYEsho`UcerWNj# zQ(Z_O%+%2Uo!Jw+a$XB{I^?T~E{yWu*^XWzpEXSrL8+XN7}os>n? z5*|F8L6G_o20Xd6HZq9xwW&6MdCWO(u%5x}tQEwZ&|zcd(K4-pGyq|`X7)CoYKLl~ z$(nnLUYaN8B}tJHDI>t`9NHOd%S#)?VdxUa>xngZXa;yZ#b8I%02^UvBFyad!Q({4 z#}EQkR(AEx4MJve-BV#|HtuSu=+X_uMjdTmg@))DuA1e$p8P{N#wTo$uc&m@`H3P= z{%){yrbP63shHBghZdObLjW>cOR*%@J?;et`~ChLLMm)k%D~edbqQd(1a2{g_AU&` zX(n7sldEpwc-$R6WM>q^`AFc5ty8xKQo4)66WQ}krOh_I5Sj^Y1hdlmLzRDi$x*Hu zhyr0rHec~f5!Su> zLLHj@o_yEAU5ZYCVf!E*T_>1=nQ9-m=~1x7CbLB0hx5=>+4A&zL%iA^Ve7o7>LGzY z;pw^sP`E|PZYfcks+MC+yktbaA2>4rw{f&L?bcztN9oL0bUD(Z9LeCULOSA3>FI0A zcgNjc(^kF|i>h^(9Zz$mjPj;TNA#?q6;92nksSn4C8*iC{TupX z^5D&M=*1RwN(U9aN(6s5HLZ=2e!Gb44!G5$1P(fpZ6Q=hd?ZxOa3Kbja=H>kVB9Kk!7HV6&eWaMm17XF! zrDHdrYAM^FV6JCuay`u@I3eA4^=%K}X;?ht?trziK;OOy&_s>b;QGEX+c)pt?E zquhWaKwh9k{I7?Xu#luQ6|E{ugT-TVSg{mpPVqsgwI2EBZXFE(umRm7BHiNY!pLLC zxkCc~a1~EQt!xst(vJ+Xlpsm}o9@c6)6I|SKKXJi*37N$E{Xu}9<%WbipMgjg*Rgm zqQq6Rk^LWj%@KrxF2|hr)is8nU}`BxCSR4}QKtvG8WmGlPFJeJqLFG%&CU+Y$5E& zJEU!haPzmjo-OrqA5LXT%IV-(SAu0*t=z)!J=IzDE$sqJD{gi*)oluqTT%pUf3|G%{J zp|QINyXtOdFD3Of@{c+K{i(gp57nbphaWy*KlvR9{@zBC-WMIoyEh|CAAqfS8dl}- zca@1i&qv4CaQAUxRogWJSA1SGOrQrS4Q=WT!4?`F%3M5 zn!PDnWSqV))`~v&sCP&H->&K=JF#X|JM>JYu16H%QB4VJtxt?;>Y4rPTGVf?k3MN~ z5BZbu9;L;65!39dna#4p=p3^Yc&M;W&TwC|(Qj=TX#*ZQZl$y)#s_UbEat*|7+o>y-I+lYYeX}g3EbCv6`o*AcqzA@g@%D8Oo*~;;TQBH)?<2x%S z(sP;PI@wrmp=TE8$uI|)GP-ni*IrlYh5M?EdKlh0dKR6cfa@B|(H^^$AV!kFfjYlQX#Xl4pMiS zj&nmo5QGU()$xdx+2A6$O@-OTzaB7M!h6tL*4*=ijg ziuTC_?Z#cyiaXa62vv1j7~^-Mm2f`!NN4^8^;IJY(WUUHP4%ux7J1A^#spK@!AoO2 zF2-P|5Y=6s^0QRTn?&7(iiq;pGv4r%g>2APzq!-TJJRA z2rEWZn5ELMB1H0iZRgK}byJ(^J00%1&|zgmy9U^&%V?9Gfmh=vG~hI9F>BkVB5lp$ zC!5?`+R42hOLb%74jU1&H&@Jo?e1ZT?4Lk z7FE16ahx-@DD8h_pQJEt!FZ0IcLNWJ&772oa?+DCypf%x9s(mmyzZ-X6BCjR$g;yb zW9_(Wd;3)S{yD_BCy864~i!<5x>Ch2R3*nI8kZ-2I<058wMCAH>QB=l91 zs$3PAtN_FHVNY!t7Iz4ZZug{43wfdCr~Xvc3I?R>-eO&a#Y0w=C|K&JlJ7=4cR4E( z&tp5fUi}mtOjn#x60*eImYcY zU^~@iGL^|Bq^s}*ZAO(AFjtTVtNvEc+Fu64(gSk|99(9cNO{8VIGnl8c7>XNteTq* zfY#o{OI*2u5~*vN=?Wd_XS6BF`h5KAEEmsAfS>kzzm=*1WPagSZmG;@D0T`ChD1(# z>GQ!)-5QbNWX?EXftWvzH}A3zQ(hDI>C*fb1kPBgs=wFGJWm-9et4UQB38i5$u5`9 z{HJ%K0J{2;NoAocBqjbK0r-t~I=zG^j!OJp z19zj$T4+5?ZY;ekb(}d8nQi^GZ{ds{*(W#R`W_jj$BqBzf3Dx;q|g`D(;2>LHZvS@ zFQvAw=xJ3rqqF1nPg+Owj-te)0O{F9oBqa09MxuNi)XlD%gmlgMX zX$oh1#OVnG=4JJ=kwFpCg$lm_x#Oyri>yw?ohu~bLwmK7UgUt;YNNR%oRoUgNCV;a zi`NfCQys#|a-AnM{RJa{@c?b>=D!E@PygfECRDNJjJ6ahh0$z1_`@Uevdj-@8-%Qo zyA=<4<~d+-x~Z$z$rWsTF&C_q3pJ`z+ zq$9Ath`7u6+g-7Qv^cf27`8Q^E0KgVIzp53#C2%!CD^zRO~RY*&C?#08nX8FlV)Wv z-UIb{aD0X%sO*I%x8JOTI+oZ>lSFo-#{i~7GN1FobzetV`E{mzt~d}a%B+c7Wxofn zGb2n9M$=N3bZa|}RL%2vZlKv(2hs%1<2n6gPCGK5T&K!8Cxc%>nc0h9bl&iPT8)xj z?o(j{Qu-VTG2mKf4&?A6nPr5;-Bf2srk}|hj0vjTM90{$l-TzjosZ??mixA|8qW13qGG&DaFEc^<%zlc~`y7_%0p6@sId7 zj6%KdrtdRTg|zJ9?s^CTxpNbj|I<0(M1k=p9@4kA%`?$9il*|Liw~XZ;K;*T1FX0k zi#>(L=qe^dDy<%^Z3%yn-MDa5qF)}eJ<*F~kVDeMJ=p9*?h|X{oux=xm`3Dz!z`Of zqCGsVKCVtLv5!V5)QFE{yF9tm_)qXboaz0IxyyEqfhC zAA5m$+x*?U6g}%O3cVxdCjU9wo-HWsAPaxUj!aoW>b||`dtQ|D73Q9s(;#s_X$qL- z@vK1{MG?L#ylb_7%NvnLp>;fN6NRqXQx!EMpR^jYy9V3ghCirDfTItun+5YD{zY&c zs^yB6n}?jbeq}sSiy6X_)?!%Bg=9wIUG_pD*BM9|mUNuIi0P2PwQ*Evdq!!l5i^6T zV-}K1+v!RBhfx^RH>haw+6-;5K6@M@hMoUbQkF#3Y0qrXe)JR^_Bcnn3xOl@3*@SgVoUF zZlAKA6I8veCEVn-eUdt*NkA3x(vZvx<7_yKLF=+fo>Aj|HxlIJCc{WXR;Pys!S?%M z@}&4z;W#bs6G`@CJTA}j5C7td{!k?i@_Wl7t#kBzNDax$iNosrbKq3x6DUp@C3q7~ zQ!=_BFqK%I)jKQ#xFZ7%6WS-grS@1*ni7a0kHqLKKR&bR{`X&hRdM>*7hv>Ni#udn z{xj`Yv>Zh;<-1|RXzLMhP%6biO7Zo2WK=QW00K)w{L0!caAebPZd_ zcuL1e&L(lG>Lk%gX*QlhxSN9%$wEE_-%%J0*1d|S77M5LQUJiYdYDzHG0{Mp!7D*r zCgfJ*Ehfv4ExiBHo@Tc&O1McHEs3RKKPbvN!(EYRlOwrdoB2PQG8i6>un0{x?O0mc z%ptkP;zVv9sxuiPo_@nhMq+axkwClsiH>nv7}tMe{L3nvGAVCKhw2^M`ECEMTx>%# zMp929ubF1;*#XK544$sY^I9bEbmc(qq~GnSO2s-O+2Y|Z@9#W{qV{92hwUlV_0-el zPvc)aulmUwddEN0w=>M~ycnNnH89;DdLHSI=%!U@z;B+7{IDnU*Ow@X3tLQ#=VLpb zbv_63V0$;X`+5s-S=E2gJjW}5bFK8&)w_BC6W^p;*w_P*G0sWv*Ug9hU(DwuE^C;F ze~Ql7;~C`2J|^Iv!t!!x&a$lYqD-wsW;tSZZbk3dq-><@LCN?D^GNx9IfUu*qpg!) zd%gCAG5FhdfrQ{xbxJ-!SlP8|;mh*f#oIGrm3}BJ5=u~GN^jiMm0{39DJ7R&`Ib3g z`N4NR89P*2U(RAg(N~HzcKspTg(m$MBZ;GJ#K=f!nB_UJ^s@F3e3G3xNTw10n)pQb z7CY~7XerpP9vZg8bxZjgLIFG!59ZQ`$GKOH&dF1pqwS73SFSEyYzyR0UACM**Kx8? zq(q}1SLq5cgv-AwHe|Uj^A|C57Tr;=$Tn%1EpwC95RPn@8yP?8yhORezeEmIYx`m!0oPF~pcAaijyDB^n%RnhHFeH=>uD%kGn`s7gyMP? z9Zbgyn5FIukPsSYgKAp^va03h&A6{PKj;TzZOF+U8}soAMvakZtP}B8ea6NYm)lF# zhT&~M1lQqlMWR!B65D{%7vqc)xP1H;zacIiw9*reaV;fPr=bDh>BGX-TT2PYXnl3P zi(Ic^AEU)gs)#)vN_tf%M=&j4El}$)bZHBy?;}Y>8tL3T7_5`%c3dH_^R^C{fRkhB z&JYj;)z=j@ClVZOxO4@?vd-deaOAb|BrF~joTiF)J@y0wO&_Msm}jt$5{S)MmN59# zcKcVQ1IDQom%irn$6tT_U3%w8g>Q!I9W^VNs5Dn>{KZ=Zi2D17H$>+cgnPSQ8{B?# zctn?>&{Z!WbR{=-QVf^l(5`W$yibsmN<^o$Z?DMhZjoWAFctH@i9#P?YWNe0b6} z1wsg_{B}Q?nIta*6S5lDw(WuT$zkga2!GG3`?9=<0l?B3s|%Nc-GI#1HWI2TdZqx2 zebq;aU4!px1+1=9J{>6{P)ckg8EIrkQy={ZtN++zz&m|3Kb)OjO=W34=Cg38xPrHH zsOHb;9%u^peaPboPq!c+e-hJ9$^<;EWz6~SGmcZ6#Q%qjUWt?S=l}G34&Flugyhc+ z%gP4`xB%&CN*GB*hWz0N%9#l}3*i+qgxkm%`$8K}$YI?~bs(-)%c`gr>^1m#i#Ez4 zsgAQjR5+J|mI@hyi}RFj@bQ#@yQxk*EiAU0MyODb`7iyG-sO1iLIBJtKLh>Y`s6u8 zudLJ6EA*EREBZi5gZrb=eU-NCh69*Eap>v_Oua(lKYg#x-%UR{HM%MKIaK9nn#p}; zNe)NC#{fxgq_p`gMXl-9?)8Apw@@znf+Krk%p6ajRB z0Ny+^mWy)X+BAFXgmrDtAvtJ4d$FkB$Q8sqfFJS!dD>zhaCEJW0`>b9afe||@ApJS zllx$}w|I}|!RNE(7N&Zr!aUAL+RsZy{faUY^)$>{z68ILmLsH1{hO#=ViA-kbmXe{ z{z&~KeTf7$CCacYnAfgd%e+*RW&yMMtZPbeAJOxfWukQpc$k$OJE8|z0IOBVBj9K4 z&kOf`Jl?QT3)Uy^iRo!yV;PY7_w-I=EE}Zv^`N4uu3cRVxpt)UuIFpKrf8l6We1_# zv$twNxrWDv>faO*bi>*g0+Y0vuhhx6gAgf0EzxE7h}TiXTlB6VwH zPnh#G&hX6lk&%kRr1S<&n@|7lU3MSZWGASUqVsx>KJcUN*T$-&UGZcd3-QfMt$Ks} zJ+%aRin0w$Ylu7?WyMo1Kcdc+?>$d|in`W}6d6nT*aJ{bN$BUJU@uQN%H5)aTCYz( ztGKkg=qZRKftIQ+!O+GYspB~cdT7GqY^v|MEzV(|lp*&V)=K877ve;>#ws1Q4xF?_ zNAO*=Jf+a@MlNm8UT|IdDF$AYQEABqkRQ}4cU!;DyGA`o_ZqM+Sj3yDYe#MFOT$3KQsqC@K zCwvdDQ}nb#uZw8}v>~Fz0kpGhm%^6uAYbB%n+4RPBs5uz)+qgj$*3i)PMW z5H&wC_{CL{kz!A+n=%57)PGfv|C!1L#6G#^gNHpJ$xU?)FFS>BQ@OTT_*t9G^psVO@-#qtmLeCOny%j+}JRZSAc#eg>q~vC~+cOWa|9 z7+zBLBraRd$U{PU?}N_%)E?b^+3DgI$1Q-3-P(#E5B_@eA_U=SKEvYbdum;DW>TXwslt|o zLnh!Ov02aatCth~#};!`(o6$_&lZOHt#Bj_=3g74VoKi1Pm*0dbtU~d*w0KK6-9nk z`$6XI>G^Of{Pj|}X}8E|arAPJ=B6&ubsBV9u=IivSEg6S;QqTU7wLLD>Y8kYWsb~} zavzR`P0Is65e44f#kPY?^JG@>8fK>ue+_(+u3MJb8>eea`6%~m#UUem$`#Aq z&dtN{)5v6ntG)*f@ohA-vu6Wu%vxolakGwsOJ{;A4?{Bcx@WxpLX!PoD5MC(eP@;%{iEUOYcm4E~?p(@|G^xAXRV z@@wQ~@_c$b`K$yuMP zi?nuc;0ga|g)w1?)AF}%9GXa)eHj09Yl_%Fjpa(C9Q7oO*W;(*LwLP; zRPK zQqB~8{$P229T`r^b-7=5QLh@Y<|T6{RCS z_pLT~dAh`4-YMw@WRaJHN}Yaf9OQtRZ01`sBXW6 ziLDx~j?<}=xMikT9urjSN}+a)VmsyxMOXyD;&};zdLCM1c*0Y?N1&$wk!YNjUGF@j zv>2wNkcUb37)97TSxyxdoMss=nTYk}kR?P?yrNdR$7#b&9>9!Sn0zus%&Eg1jOtG7 z$&8rHAN=pcM?@99A0UU&hSJQN`9HH;NcD>T)#r%EaE$V^J8YJgow4@FqUb;B5YRT= zJIkE%(vv6)*+0n^vp%p&TH@#4a*#VZi^LC~rZein4+SM%rc^qhfz8ip|{kw;yiPk1WSoEzn*g58fzG8sZ$GFFyMPc}gZ za0yg3Dv*=W9C`L+>91MQ=wfO5KCIp#*AomuIXz|zM~F|Ot@Qy8O!vH_;^Jg*<<3d2 z6B-?7-<%YbO_ElxSJ#elsQSWcM2YnBAf%uHvtNiu>OxgN<)6S9-N4G}56t91c(mX{ zXV3HSI8rz3IHQs`$}sZc8t9svoR7u`nbrjCav;g8&ni=7+e^i1{3|{9Er2waTSF?; z0gq$mABE1X!h?aYefLT5Zp{=(7-SL>8$`3XdvysLpE0Y{(@fnZp@+H^uu_L32tXhkjoVUv$ zLC0&huGUX7&SWbeUzccLJtIKX1ptG)X6oj{Kv^ePra_f2Kj%CIR!4xDt5dw>wf@do zPr{)t=Tu0aVw&)%7^RD-s|0;ZyeJ5{$Rv}pJm(w1;V9W--%L6$40Q!*Y~>C2t98CK5)I<8qiKf-Sc-huty~%>Xi_#li=Y zHOz!)TzPy@%@s(NI~k~8nNti&($e3mG8$t#HjK+~HYWkHngc^Q+ZRE68Y_*jJS-EZ zU5qZFJ!E6}18xeHav!=nkyK0;qQRsx6+M}_b-%87FBc0Dh_}F`(^33plYov2oKIip zG*gQqXG>08$t9MxiMfq9zaW9yX#wt{`sx@w%1micu=o}uwS%UDkgZ!Nd-OO*G{OQ& zF4Qh!{Q5p4knjEr@NHsg5t5Vvr|rE&?qxl`7IDqgV`ufA z0LW^f1{pC#VRk1hLgF@PCG9v6n?f!YWh644PR!7~1Vx*A@&KqhwGqjtKn=w>@>0=7 z2H3m7%doLf)Bo!IL!m8wmcAT)cV>5d7P+-$l)^gnZO zM__PP88B(vqy##e5^^9QQ9>n$DC0Qo7p2paJGHdbW$sfUp5te8h~}y&=dRoyrbzbi z({FZ4c_+OV9#lX@3rO7VgkF;}42lWZOGRTE)%~7$5kXz=>?klz^Q87EM~OPP3At)a z+9aOUx!W!J4CeS>R`=u@i|E-Ylj!Z+q-7r(rnKb*FrB^x90wfA>?tO&YZbJ10YS#s zr^g|}vLGd++H1ir;!W5)#rX`F{51>mQ!3U^cl77*J72fMcXC?(@yHS|`o^$Rfi+8K zBJ4QbQfXbtwCW0{T*Q#!Df{kxaFrb9#GT$_J89J;DM=cRB;*c7>jZE>WjQwlI}d0f zn4ZjOw*BLo>^gmeY{K|k2Hum>nCm$zgL_qUAI$+6eNkCFol*qNZd@;x&I9Yj2Ca!j z_R1Q}hwaeaU_nm2xLR&pAXNzRY}ejRa6a)W4al$SGaxLdFO8!g6u{pCuqWYiYP&!{ip~TFXRAYTuVzkGXC%1&b>ter6OD-WQ}=$;M}tGsRL6Md zj?ET?p!(lMDbiJDK2DXl9KBJQf&E4dK)B7>TWD3l`?IumsJ)(E7mVyGA+5KD1_f38G2h>O~vQ&I*d`YMV@D6PyUD82n22 z3+MgG6hIh7`cmFA3PpmaLM&tIriW;{6i!r7cvts!5vwmfQWS?TG7|T*mHt2ybm~+V z)3cjqe0iQ(G5U+jwOo7@BuRJD8!Wpu7ySk6^X`|ZumDI`9!y2xG7CZAB`HZyMRknH zh_-s#ac;CLKpv1Ac1m&r9&I^!MCJz;UUJ5Dn9LLMGMM)Yte%YDvIV*XvdMiPUB9KL9hYgcB`g$PxP27$L$Yb*s3 z4^3a5;vq@JIVv8JSa3rD-x4}5?RjE4Y^c4+X28e3&=7WT*5X9 e7-Z`2RsSD@?HL9f?m6}V0000