✨ Now documents and chunks support semantic search

Author: Phinease

backend/apps/vectordatabase_app.py

@@ -5,7 +5,7 @@
 from fastapi import APIRouter, Body, Depends, Header, HTTPException, Path, Query
 from fastapi.responses import JSONResponse
 
-from consts.model import IndexingResponse
+from consts.model import HybridSearchRequest, IndexingResponse
 from nexent.vector_database.base import VectorDatabaseCore
 from services.vectordatabase_service import (
     ElasticSearchService,
@@ -226,3 +226,32 @@ def get_index_chunks(
             f"Error getting chunks for index '{index_name}': {error_msg}")
         raise HTTPException(
             status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=f"Error getting chunks: {error_msg}")
+
+
+@router.post("/search/hybrid")
+async def hybrid_search(
+        payload: HybridSearchRequest,
+        vdb_core: VectorDatabaseCore = Depends(get_vector_db_core),
+        authorization: Optional[str] = Header(None),
+):
+    """Run a hybrid (accurate + semantic) search across indices."""
+    try:
+        _, tenant_id = get_current_user_id(authorization)
+        result = ElasticSearchService.search_hybrid(
+            index_names=payload.index_names,
+            query=payload.query,
+            tenant_id=tenant_id,
+            top_k=payload.top_k,
+            weight_accurate=payload.weight_accurate,
+            vdb_core=vdb_core,
+        )
+        return JSONResponse(status_code=HTTPStatus.OK, content=result)
+    except ValueError as exc:
+        raise HTTPException(status_code=HTTPStatus.BAD_REQUEST,
+                            detail=str(exc))
+    except Exception as exc:
+        logger.error(f"Hybrid search failed: {exc}", exc_info=True)
+        raise HTTPException(
+            status_code=HTTPStatus.INTERNAL_SERVER_ERROR,
+            detail=f"Error executing hybrid search: {str(exc)}",
+        )

backend/consts/model.py

@@ -175,6 +175,18 @@ class IndexingResponse(BaseModel):
     total_submitted: int
 
 
+class HybridSearchRequest(BaseModel):
+    """Request payload for hybrid knowledge-base searches."""
+    query: str = Field(..., min_length=1,
+                       description="Search query text")
+    index_names: List[str] = Field(..., min_items=1,
+                                   description="List of index names to search")
+    top_k: int = Field(10, ge=1, le=100,
+                       description="Number of results to return")
+    weight_accurate: float = Field(0.5, ge=0.0, le=1.0,
+                                   description="Weight applied to accurate search scores")
+
+
 # Request models
 class ProcessParams(BaseModel):
     chunking_strategy: Optional[str] = "basic"

backend/services/vectordatabase_service.py

@@ -996,3 +996,66 @@ def get_index_chunks(
             error_msg = f"Error retrieving chunks from index {index_name}: {str(e)}"
             logger.error(error_msg)
             raise Exception(error_msg)
+
+    @staticmethod
+    def search_hybrid(
+            *,
+            index_names: List[str],
+            query: str,
+            tenant_id: str,
+            top_k: int = 10,
+            weight_accurate: float = 0.5,
+            vdb_core: VectorDatabaseCore = Depends(get_vector_db_core),
+    ):
+        """
+        Execute a hybrid search that blends accurate and semantic scoring.
+        """
+        try:
+            if not tenant_id:
+                raise ValueError("Tenant ID is required for hybrid search")
+            if not query or not query.strip():
+                raise ValueError("Query text is required for hybrid search")
+            if not index_names:
+                raise ValueError("At least one index name is required")
+            if top_k <= 0:
+                raise ValueError("top_k must be greater than 0")
+            if weight_accurate < 0 or weight_accurate > 1:
+                raise ValueError("weight_accurate must be between 0 and 1")
+
+            embedding_model = get_embedding_model(tenant_id)
+            if not embedding_model:
+                raise ValueError(
+                    "No embedding model configured for the current tenant")
+
+            start_time = time.perf_counter()
+            raw_results = vdb_core.hybrid_search(
+                index_names=index_names,
+                query_text=query,
+                embedding_model=embedding_model,
+                top_k=top_k,
+                weight_accurate=weight_accurate,
+            )
+            elapsed_ms = int((time.perf_counter() - start_time) * 1000)
+
+            formatted_results = []
+            for item in raw_results:
+                document = dict(item.get("document", {}))
+                document["score"] = item.get("score")
+                document["index"] = item.get("index")
+                if "scores" in item:
+                    document["score_details"] = item["scores"]
+                formatted_results.append(document)
+
+            return {
+                "results": formatted_results,
+                "total": len(formatted_results),
+                "query_time_ms": elapsed_ms,
+            }
+        except ValueError:
+            raise
+        except Exception as exc:
+            logger.error(
+                f"Hybrid search failed for indices {index_names}: {exc}",
+                exc_info=True,
+            )
+            raise Exception(f"Error executing hybrid search: {str(exc)}")