feat(db): add SQLite fallback for embedding similarity search

Implement cosine similarity computation in Python for SQLite databases,
enabling vector search functionality that was previously unsupported.
This change allows users on SQLite to perform embedding searches with
proper scoring and sorting, improving compatibility across database types.

Author: OthmaneBlial

backend/modules/knowledge/crud.py

@@ -2,6 +2,8 @@
 from sqlalchemy import select, delete
 from typing import List, Optional, Dict, Any
 from uuid import UUID
+import math
+import json
 
 from backend.core.database import normalize_uuid, is_sqlite
 from .models import KnowledgeBase, Document, Paragraph, Embedding
@@ -204,11 +206,77 @@ async def search_embeddings_by_similarity(
     db_kb_id = normalize_uuid(knowledge_base_id) if knowledge_base_id else None
     db_app_id = normalize_uuid(application_id) if application_id else None
 
-    bind = db.get_bind()
-    dialect_name = getattr(bind.dialect, "name", None) if bind is not None else None
-
-    if is_sqlite or dialect_name == "sqlite":
-        return []
+    if is_sqlite:
+        # SQLite fallback: fetch candidate vectors and compute cosine in Python
+        query = """
+        SELECT
+            e.id as embedding_id,
+            e.vector as embedding_vector,
+            e.paragraph_id,
+            p.content as paragraph_content,
+            p.document_id,
+            d.title as document_title,
+            d.knowledge_base_id
+        FROM embeddings e
+        JOIN paragraphs p ON e.paragraph_id = p.id
+        JOIN documents d ON p.document_id = d.id
+        """
+
+        params = {}
+        where_conditions = []
+        if db_kb_id:
+            where_conditions.append("d.knowledge_base_id = :kb_id")
+            params["kb_id"] = db_kb_id
+        if db_app_id:
+            where_conditions.append("d.application_id = :app_id")
+            params["app_id"] = db_app_id
+
+        if where_conditions:
+            query += " WHERE " + " AND ".join(where_conditions)
+
+        result = await db.execute(text(query), params)
+        rows = result.fetchall()
+
+        def _coerce_vector(raw_value):
+            if raw_value is None:
+                return []
+            if isinstance(raw_value, (bytes, bytearray, memoryview)):
+                raw_value = raw_value.decode("utf-8")
+            if isinstance(raw_value, str):
+                try:
+                    raw_value = json.loads(raw_value)
+                except json.JSONDecodeError:
+                    raw_value = []
+            return [float(x) for x in raw_value]
+
+        def cosine_similarity(vec_a, vec_b):
+            dot = sum(a * b for a, b in zip(vec_a, vec_b))
+            norm_a = math.sqrt(sum(a * a for a in vec_a))
+            norm_b = math.sqrt(sum(b * b for b in vec_b))
+            if not norm_a or not norm_b:
+                return 0.0
+            return dot / (norm_a * norm_b)
+
+        scored_rows = []
+        for row in rows:
+            stored_vector = _coerce_vector(row.embedding_vector)
+            score = cosine_similarity(stored_vector, query_vector)
+            if threshold is None or score >= threshold:
+                scored_rows.append(
+                    {
+                        "embedding_id": row.embedding_id,
+                        "paragraph_id": row.paragraph_id,
+                        "document_id": row.document_id,
+                        "knowledge_base_id": row.knowledge_base_id,
+                        "paragraph_content": row.paragraph_content,
+                        "document_title": row.document_title,
+                        "similarity_score": float(score),
+                        "embedding_vector": stored_vector,
+                    }
+                )
+
+        scored_rows.sort(key=lambda r: r["similarity_score"], reverse=True)
+        return scored_rows[:limit]
 
     # PostgreSQL path with pgvector
     query = """
@@ -289,9 +357,6 @@ async def search_paragraphs_by_text(
     # Generate embedding for query text
     query_vector = await encode_text(query_text)
 
-    if is_sqlite:
-        return []
-
     # Search for similar embeddings
     return await search_embeddings_by_similarity(
         db, query_vector, limit, knowledge_base_id, application_id

ragify.db

@@ -832,20 +832,19 @@ async def test_get_embeddings_stats_filtered(self, db_session):
     @pytest.mark.asyncio
     async def test_search_embeddings_by_similarity_sqlite_compatibility(self, db_session):
         """Test search embeddings by similarity (graceful SQLite compatibility)"""
-        # Since we're using SQLite, pgvector operations won't work
-        # This test verifies the function handles SQLite gracefully and returns empty results
+        # Ensure SQLite fallback returns cosine-sorted matches (not empty)
         query_vector = [0.1, 0.2, 0.3] * 128
 
-        # This should now handle SQLite gracefully and return empty results
         results = await search_embeddings_by_similarity(
             db=db_session,
             query_vector=query_vector,
             limit=5
         )
 
-        # Should return empty list for SQLite compatibility
         assert isinstance(results, list)
-        assert len(results) == 0
+        assert len(results) > 0
+        assert "similarity_score" in results[0]
+        assert all("paragraph_content" in row for row in results)
 
     @pytest.mark.asyncio
     async def test_search_paragraphs_by_text(self, db_session):
@@ -864,14 +863,13 @@ async def test_search_paragraphs_by_text(self, db_session):
         with patch('backend.modules.rag.embedding.encode_text') as mock_encode:
             mock_encode.return_value = vector
 
-            # This should now handle SQLite gracefully and return empty results
             results = await search_paragraphs_by_text(
                 db=db_session,
                 query_text="test query",
                 limit=5
             )
 
-            # Should return empty list for SQLite compatibility
             assert isinstance(results, list)
-            assert len(results) == 0
+            assert len(results) > 0
+            assert all("similarity_score" in row for row in results)
             mock_encode.assert_called_once_with("test query")