chore: remaining working-tree changes

app/api/v1/vector_stores.py

@@ -14,7 +14,11 @@ from fastapi import (
     status,
 )
 
-from app.api.deps import get_vector_store_service
+from app.api.deps import (
+    get_converter_service,
+    get_text_cleaner_service,
+    get_vector_store_service,
+)
 from app.core.logger import get_logger
 from app.models.domain import ConversionError
 from app.models.schemas import (
@@ -38,18 +42,22 @@ router = APIRouter()
 logger = get_logger(__name__)
 
 
-async def _process_pdf_bytes(raw: bytes, source: str, clean_content: bool) -> str | ConversionError:
+async def _process_pdf_bytes(
+    raw: bytes,
+    source: str,
+    clean_content: bool,
+    converter_service: ConverterService,
+    text_cleaner_service: TextCleanerService,
+) -> str | ConversionError:
     if len(raw) < 5 or raw[:5] != b"%PDF-":
         return ConversionError(source=source, error_type="ValueError", message="Not a valid PDF", duration_ms=0)
     loop = asyncio.get_running_loop()
-    converter = ConverterService()
-    result = await loop.run_in_executor(None, converter.convert_stream, raw, source)
+    result = await loop.run_in_executor(None, converter_service.convert_stream, raw, source)
     if isinstance(result, ConversionError):
         return result
     text = result.markdown
     if clean_content:
-        text_cleaner = TextCleanerService()
-        text = await loop.run_in_executor(None, text_cleaner.clean, text)
+        text = await loop.run_in_executor(None, text_cleaner_service.clean, text)
     return text
 
 
@@ -214,6 +222,8 @@ async def ingest_pdf_document(
     chunk_overlap: int = Form(64, ge=0, le=512),
     clean_content: bool = Query(True, description="Clean markdown text after PDF conversion"),
     vector_store_service: VectorStoreService = Depends(get_vector_store_service),
+    converter_service: ConverterService = Depends(get_converter_service),
+    text_cleaner_service: TextCleanerService = Depends(get_text_cleaner_service),
 ) -> DocumentIngestResponse:
     record = vector_store_service.get_store(store_id)
     if record is None:
@@ -229,7 +239,9 @@ async def ingest_pdf_document(
     finally:
         await file.close()
 
-    text = await _process_pdf_bytes(raw, file.filename, clean_content)
+    text = await _process_pdf_bytes(
+        raw, file.filename, clean_content, converter_service, text_cleaner_service
+    )
     if isinstance(text, ConversionError):
         return DocumentIngestResponse(
             success=False,
@@ -279,6 +291,8 @@ async def ingest_pdf_url(
     body: DocumentIngestUrlRequest,
     clean_content: bool = Query(True, description="Clean markdown text after PDF conversion"),
     vector_store_service: VectorStoreService = Depends(get_vector_store_service),
+    converter_service: ConverterService = Depends(get_converter_service),
+    text_cleaner_service: TextCleanerService = Depends(get_text_cleaner_service),
 ) -> DocumentIngestResponse:
     record = vector_store_service.get_store(store_id)
     if record is None:
@@ -296,7 +310,9 @@ async def ingest_pdf_url(
             error=f"Failed to fetch PDF from URL: {exc}",
         )
 
-    text = await _process_pdf_bytes(raw, body.url, clean_content)
+    text = await _process_pdf_bytes(
+        raw, body.url, clean_content, converter_service, text_cleaner_service
+    )
     if isinstance(text, ConversionError):
         return DocumentIngestResponse(
             success=False,

app/api/v1/web_search.py

@@ -20,9 +20,11 @@ from app.services.web_search_service import WebSearchService
 router = APIRouter()
 _logger = get_logger(__name__)
 
+_search_service = WebSearchService()
+
 
 def get_search_service() -> WebSearchService:
-    return WebSearchService()
+    return _search_service
 
 
 @router.post(

app/services/semantic_router_service.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
 import logging
-from collections import defaultdict
-from typing import Any
+from typing import Any, Dict, List, Optional
 
 import numpy as np
+from semantic_router import Route
+from semantic_router.encoders import DenseEncoder
+from semantic_router.linear import similarity_matrix
+from semantic_router.routers import SemanticRouter
 
 from app.services.embeddings_service import EmbeddingService
 
@@ -13,6 +16,33 @@ _logger = logging.getLogger(__name__)
 _DIMENSION = 384
 
 
+class _EmbeddingServiceEncoder(DenseEncoder):
+    """Adapter exposing the project's EmbeddingService as a semantic-router encoder.
+
+    Wrapping the already-loaded sentence-transformers model avoids loading a second
+    embedding model just for routing.
+    """
+
+    def __init__(
+        self,
+        embedding_service: EmbeddingService,
+        dimension: int = _DIMENSION,
+        score_threshold: Optional[float] = None,
+    ) -> None:
+        super().__init__(
+            name="granite-embedding-small-english-r2",
+            score_threshold=score_threshold,
+        )
+        self._embedding_service = embedding_service
+        self._dimension = dimension
+
+    def __call__(self, docs: List[Any]) -> List[List[float]]:
+        return self._embedding_service.generate_embedding([str(d) for d in docs], self._dimension)
+
+    async def acall(self, docs: List[Any]) -> List[List[float]]:
+        return self(docs)
+
+
 class SemanticRouterService:
     def __init__(self, embedding_service: EmbeddingService) -> None:
         self._embedding_service = embedding_service
@@ -27,70 +57,76 @@ class SemanticRouterService:
             return {"success": False, "name": None, "models": [], "error": "Query is empty."}
         if not routes:
             return {"success": False, "name": None, "models": [], "error": "No routes provided."}
-
         if not self._embedding_service.is_loaded(_DIMENSION):
             return {"success": False, "name": None, "models": [], "error": "Embedding model not loaded."}
 
-        all_utterances: list[str] = []
-        utterance_to_route: list[int] = []
+        valid_routes = [r for r in routes if r.get("utterances")]
+        if not valid_routes:
+            return {"success": False, "name": None, "models": [], "error": "No utterances found in any route."}
 
-        for idx, route in enumerate(routes):
-            utterances = route.get("utterances", [])
-            if not utterances:
-                continue
-            all_utterances.extend(utterances)
-            utterance_to_route.extend([idx] * len(utterances))
+        name_to_models: Dict[str, List[str]] = {r["name"]: r.get("models", []) for r in routes}
 
-        if not all_utterances:
-            return {"success": False, "name": None, "models": [], "error": "No utterances found in any route."}
+        encoder = _EmbeddingServiceEncoder(self._embedding_service, score_threshold=threshold)
+        lib_routes = [Route(name=r["name"], utterances=r["utterances"]) for r in valid_routes]
+        total_utterances = sum(len(r.utterances) for r in lib_routes)
 
         try:
-            all_texts = all_utterances + [query]
-            embeddings = self._embedding_service.generate_embedding(all_texts, _DIMENSION)
+            router = SemanticRouter(
+                encoder=encoder,
+                routes=lib_routes,
+                auto_sync="local",
+                aggregation="max",
+                top_k=total_utterances,
+            )
+            # Encode the query once, then reuse the vector for both the router
+            # decision and the per-route margin / matched-utterance computation.
+            query_vector = np.asarray(encoder([query])[0], dtype=np.float32)
+            choice = router(vector=query_vector)
+            if isinstance(choice, list):
+                choice = choice[0] if choice else None
+
+            sims = similarity_matrix(query_vector, router.index.index)
+            scores_by_route: Dict[str, float] = {}
+            for route_name, score in zip(router.index.routes, sims):
+                scores_by_route[str(route_name)] = max(
+                    scores_by_route.get(str(route_name), float("-inf")), float(score)
+                )
+            sorted_routes = sorted(scores_by_route.items(), key=lambda x: x[1], reverse=True)
+            best_score = sorted_routes[0][1]
+            second_best = sorted_routes[1][1] if len(sorted_routes) > 1 else 1.0
+            margin = best_score - second_best
+            best_utt_idx = int(np.argmax(sims))
+            matched_utterance = str(router.index.utterances[best_utt_idx])
         except Exception as exc:
-            _logger.error("Embedding failed: %s", exc)
+            _logger.error("Semantic routing failed: %s", exc)
             return {"success": False, "name": None, "models": [], "error": str(exc)}
 
-        utterance_embs = np.array(embeddings[:-1], dtype=np.float32)
-        query_emb = np.array(embeddings[-1], dtype=np.float32).reshape(1, -1)
-
-        similarities = (utterance_embs @ query_emb.T).flatten()
-        best_idx = int(np.argmax(similarities))
-        best_score = float(similarities[best_idx])
+        name = choice.name if choice is not None else None
+        confidence = (
+            float(choice.similarity_score)
+            if choice is not None and choice.similarity_score is not None
+            else best_score
+        )
 
-        # Route-level scoring: take the max score per route
-        route_scores: dict[int, list[float]] = defaultdict(list)
-        for i, score in enumerate(similarities):
-            route_scores[utterance_to_route[i]].append(float(score))
-
-        route_best_scores = {rid: max(scores) for rid, scores in route_scores.items()}
-        sorted_routes = sorted(route_best_scores.items(), key=lambda x: x[1], reverse=True)
-        best_route_score = sorted_routes[0][1]
-        second_best_route_score = sorted_routes[1][1] if len(sorted_routes) > 1 else 1.0
-        route_margin = best_route_score - second_best_route_score
-
-        if best_score < threshold or route_margin < 0.001:
+        if name is None or margin < 0.001:
             return {
                 "success": True,
                 "name": None,
                 "models": [],
                 "error": None,
-                "confidence": best_score,
-                "margin": route_margin,
+                "confidence": confidence,
+                "margin": margin,
                 "threshold": threshold,
-                "matched_utterance": all_utterances[best_idx],
+                "matched_utterance": matched_utterance,
             }
 
-        matched_route_idx = utterance_to_route[best_idx]
-        matched_route = routes[matched_route_idx]
-
         return {
             "success": True,
-            "name": matched_route.get("name"),
-            "models": matched_route.get("models", []),
+            "name": name,
+            "models": name_to_models.get(name, []),
             "error": None,
-            "confidence": best_score,
-            "margin": route_margin,
+            "confidence": confidence,
+            "margin": margin,
             "threshold": threshold,
-            "matched_utterance": all_utterances[best_idx],
+            "matched_utterance": matched_utterance,
         }

pyproject.toml

@@ -24,6 +24,7 @@ dependencies = [
     "pyfiglet>=1.0.0",
     "rich>=13.7",
     "numpy>=1.26.0",
+    "semantic-router>=0.1.16",
     "rapidocr-onnxruntime>=1.4.4",
     "onnxruntime>=1.18.0",
     "pillow>=10.0.0",