ok

app/api/v1/router.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from fastapi import APIRouter
 
-from app.api.v1 import batch, chat, code_executor, convert, database, embeddings, reconcile, scraper, sql_validator, system, web_search
+from app.api.v1 import batch, chat, code_executor, convert, database, embeddings, reconcile, scraper, semantic_router, sql_validator, system, token_counter, web_search
 from app.api.verify import router as verify_router
 
 api_v1_router = APIRouter()
@@ -17,4 +17,6 @@ api_v1_router.include_router(reconcile.router, tags=["Reconcile"])
 api_v1_router.include_router(scraper.router, tags=["Web Scraping"])
 api_v1_router.include_router(web_search.router, tags=["Web Search"])
 api_v1_router.include_router(sql_validator.router, tags=["SQL Validator"])
+api_v1_router.include_router(semantic_router.router, tags=["Semantic Router"])
+api_v1_router.include_router(token_counter.router, tags=["Token Counter"])
 api_v1_router.include_router(chat.router, tags=["Chat"])

app/api/v1/semantic_router.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import time
+
+from fastapi import APIRouter, Depends
+
+from app.api.deps import get_embeddings_service, require_auth
+from app.models.schemas import SemanticRouterRequest, SemanticRouterResponse
+from app.services.embeddings_service import EmbeddingService
+from app.services.semantic_router_service import SemanticRouterService
+
+router = APIRouter()
+
+
+@router.post(
+    "/semantic-router/route",
+    response_model=SemanticRouterResponse,
+    summary="Route a query to the best matching route using semantic similarity",
+)
+async def route_query(
+    body: SemanticRouterRequest,
+    token: str = Depends(require_auth),
+    embedding_service: EmbeddingService = Depends(get_embeddings_service),
+) -> SemanticRouterResponse:
+    start = time.perf_counter()
+    svc = SemanticRouterService(embedding_service)
+    routes_dict = [r.model_dump() for r in body.routes]
+    result = svc.route(body.query, routes_dict, body.threshold)
+    elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
+    return SemanticRouterResponse(
+        success=result["success"],
+        time_ms=elapsed_ms,
+        name=result.get("name"),
+        models=result.get("models", []),
+        error=result.get("error"),
+        confidence=result.get("confidence"),
+        threshold=result.get("threshold"),
+        matched_utterance=result.get("matched_utterance"),
+    )

app/api/v1/token_counter.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import time
+
+from fastapi import APIRouter, Depends
+
+from app.api.deps import require_auth
+from app.models.domain import count_tokens
+from app.models.schemas import TokenCountRequest, TokenCountResponse
+
+router = APIRouter()
+
+
+@router.post(
+    "/token/count",
+    response_model=TokenCountResponse,
+    summary="Count tokens in text using tiktoken",
+)
+async def count_text_tokens(
+    body: TokenCountRequest,
+    token: str = Depends(require_auth),
+) -> TokenCountResponse:
+    start = time.perf_counter()
+    try:
+        token_count = count_tokens(body.text, body.encoding)
+        elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
+        return TokenCountResponse(
+            success=True,
+            time_ms=elapsed_ms,
+            token_count=token_count,
+            char_count=len(body.text),
+            encoding=body.encoding,
+        )
+    except Exception as exc:
+        elapsed_ms = round((time.perf_counter() - start) * 1000, 3)
+        return TokenCountResponse(
+            success=False,
+            time_ms=elapsed_ms,
+            error=str(exc),
+        )

app/models/schemas.py

@@ -6,6 +6,44 @@ from typing import Any, Dict, List, Literal, Optional
 from pydantic import BaseModel, Field, field_validator, model_validator
 
 
+class RouteConfig(BaseModel):
+    name: str = Field(..., min_length=1, description="Route name")
+    utterances: List[str] = Field(..., min_length=1, description="Example phrases for this route")
+    models: List[str] = Field(default_factory=list, description="Model identifiers assigned to this route")
+
+
+class SemanticRouterRequest(BaseModel):
+    query: str = Field(..., min_length=1, max_length=50000, description="User query to route")
+    routes: List[RouteConfig] = Field(..., min_length=1, description="Route definitions")
+    threshold: float = Field(default=0.3, ge=0.0, le=1.0, description="Minimum similarity score to match")
+
+
+class SemanticRouterResponse(BaseModel):
+    success: bool
+    time_ms: float
+    name: Optional[str] = None
+    models: List[str] = []
+    error: Optional[str] = None
+    confidence: Optional[float] = None
+    margin: Optional[float] = None
+    threshold: Optional[float] = None
+    matched_utterance: Optional[str] = None
+
+
+class TokenCountRequest(BaseModel):
+    text: str = Field(..., min_length=1, max_length=1000000, description="Text to count tokens for")
+    encoding: str = Field(default="o200k_base", description="TikToken encoding name")
+
+
+class TokenCountResponse(BaseModel):
+    success: bool
+    time_ms: float
+    token_count: int = 0
+    char_count: int = 0
+    encoding: str = "o200k_base"
+    error: Optional[str] = None
+
+
 
 class ConversionMetadata(BaseModel):
     source: str

app/services/semantic_router_service.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Optional
+
+import numpy as np
+
+from app.services.embeddings_service import EmbeddingService
+
+_logger = logging.getLogger(__name__)
+
+_DIMENSION = 384
+
+
+class SemanticRouterService:
+    def __init__(self, embedding_service: EmbeddingService) -> None:
+        self._embedding_service = embedding_service
+
+    def route(
+        self,
+        query: str,
+        routes: list[dict[str, Any]],
+        threshold: float = 0.7,
+    ) -> dict[str, Any]:
+        if not query or not query.strip():
+            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] = []
+
+        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))
+
+        if not all_utterances:
+            return {"success": False, "name": None, "models": [], "error": "No utterances found in any route."}
+
+        try:
+            all_texts = all_utterances + [query]
+            embeddings = self._embedding_service.generate_embedding(all_texts, _DIMENSION)
+        except Exception as exc:
+            _logger.error("Embedding 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])
+
+        sorted_scores = sorted(similarities, reverse=True)
+        margin = (sorted_scores[0] - sorted_scores[1]) if len(sorted_scores) > 1 else 1.0
+
+        if best_score < threshold or margin < 0.01:
+            return {
+                "success": True,
+                "name": None,
+                "models": [],
+                "error": None,
+                "confidence": best_score,
+                "margin": margin,
+                "threshold": threshold,
+                "matched_utterance": all_utterances[best_idx],
+            }
+
+        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", []),
+            "error": None,
+            "confidence": best_score,
+            "margin": margin,
+            "threshold": threshold,
+            "matched_utterance": all_utterances[best_idx],
+        }