| |
| """Serve the local DeepResearch-9K SQLite corpus with the Miles search API.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import os |
| import sqlite3 |
| import time |
| from contextlib import asynccontextmanager |
| from pathlib import Path |
| from typing import Any |
|
|
| import uvicorn |
| from fastapi import FastAPI, HTTPException |
| from fastapi.middleware.cors import CORSMiddleware |
| from pydantic import BaseModel, Field |
|
|
| try: |
| from .corpus_db import connect, fts_counts, fts_exists, open_document, search, status_counts |
| except ImportError: |
| from corpus_db import connect, fts_counts, fts_exists, open_document, search, status_counts |
|
|
|
|
| class QueryRequest(BaseModel): |
| query: str = Field(..., min_length=1) |
| k: int = Field(20, ge=1, le=100) |
|
|
|
|
| class OpenRequest(BaseModel): |
| docid: str | None = None |
| url: str | None = None |
|
|
|
|
| class QueryResponse(BaseModel): |
| results: list[dict[str, Any]] |
| took_ms: float |
|
|
|
|
| connection: sqlite3.Connection | None = None |
| blocked_docids: frozenset[str] = frozenset() |
|
|
|
|
| @asynccontextmanager |
| async def lifespan(_app: FastAPI): |
| global blocked_docids, connection |
| database = Path(os.environ.get("DEEPRESEARCH9K_CORPUS_DB", "deepresearch9k_corpus.sqlite3")) |
| if not database.exists(): |
| raise RuntimeError(f"corpus database does not exist: {database}") |
| blocked_path_value = os.environ.get("DEEPRESEARCH9K_BLOCKED_DOCIDS_FILE", "").strip() |
| if blocked_path_value: |
| blocked_path = Path(blocked_path_value) |
| if not blocked_path.exists(): |
| raise RuntimeError(f"blocked-docids file does not exist: {blocked_path}") |
| blocked_docids = frozenset( |
| line.strip() for line in blocked_path.read_text().splitlines() if line.strip() |
| ) |
| else: |
| blocked_docids = frozenset() |
| connection = connect(database, readonly=True) |
| try: |
| if not fts_exists(connection): |
| raise RuntimeError(f"FTS index is missing in {database}; run build_index.py") |
| yield |
| finally: |
| connection.close() |
| connection = None |
|
|
|
|
| app = FastAPI(title="DeepResearch-9K local FTS search", lifespan=lifespan) |
| app.add_middleware( |
| CORSMiddleware, |
| allow_origins=["*"], |
| allow_credentials=True, |
| allow_methods=["*"], |
| allow_headers=["*"], |
| ) |
|
|
|
|
| def get_connection() -> sqlite3.Connection: |
| if connection is None: |
| raise HTTPException(status_code=503, detail="search database is not initialized") |
| return connection |
|
|
|
|
| @app.post("/search", response_model=QueryResponse) |
| async def search_endpoint(request: QueryRequest) -> QueryResponse: |
| started = time.perf_counter() |
| if not request.query.strip(): |
| raise HTTPException(status_code=400, detail="query must be a non-empty string") |
| try: |
| results = search( |
| get_connection(), request.query, request.k, excluded_docids=blocked_docids |
| ) |
| except ValueError as exc: |
| raise HTTPException(status_code=400, detail=str(exc)) from exc |
| return QueryResponse(results=results, took_ms=(time.perf_counter() - started) * 1000) |
|
|
|
|
| @app.post("/open", response_model=QueryResponse) |
| async def open_endpoint(request: OpenRequest) -> QueryResponse: |
| started = time.perf_counter() |
| if not request.docid and not request.url: |
| raise HTTPException(status_code=400, detail="docid or url is required") |
| result = open_document(get_connection(), docid=request.docid, url=request.url) |
| if result is not None and result["docid"] in blocked_docids: |
| result = None |
| if result is None: |
| lookup = request.docid or request.url or "" |
| result = { |
| "docid": request.docid or "", |
| "url": request.url or "", |
| "text": f"document not indexed: {lookup}", |
| } |
| else: |
| title = result.pop("title", "").strip() |
| result["text"] = f"{title}\n\n{result['text']}".strip() |
| return QueryResponse(results=[result], took_ms=(time.perf_counter() - started) * 1000) |
|
|
|
|
| @app.get("/health") |
| async def health() -> dict[str, Any]: |
| current = get_connection() |
| indexed = fts_counts(current) |
| return { |
| "status": "healthy", |
| "retrieval_mode": "sqlite_fts5_bm25_chunked", |
| "indexed_documents": indexed["documents"], |
| "indexed_chunks": indexed["chunks"], |
| "blocked_documents": len(blocked_docids), |
| } |
|
|
|
|
| @app.get("/stats") |
| async def stats() -> dict[str, Any]: |
| current = get_connection() |
| indexed = fts_counts(current) |
| return { |
| "retrieval_mode": "sqlite_fts5_bm25_chunked", |
| "indexed_documents": indexed["documents"], |
| "indexed_chunks": indexed["chunks"], |
| "fetch_status": status_counts(current), |
| "blocked_documents": len(blocked_docids), |
| } |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--database", type=Path, required=True) |
| parser.add_argument("--host", default="0.0.0.0") |
| parser.add_argument("--port", type=int, default=8011) |
| args = parser.parse_args() |
| os.environ["DEEPRESEARCH9K_CORPUS_DB"] = str(args.database.resolve()) |
| uvicorn.run(app, host=args.host, port=args.port) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
