fix: Enable automatic embedding generation for vector search

- Changed enable_embeddings default to true in MemoryService
- Added generate_embedding parameter to create_memory method
- Fixed vector format conversion for PostgreSQL (list to string)
- Created _format_vector helper method for consistent formatting
- Fixed hybrid_search function ambiguity issue
- Added vector_weight parameter to hybrid search calls
- Vector and hybrid search now working correctly with embeddings

Author: raold

app/services/memory_service.py

@@ -22,9 +22,11 @@ class MemoryService:
     def __init__(self):
         """Initialize PostgreSQL memory service"""
         db_url = os.getenv("DATABASE_URL", "postgresql://secondbrain:changeme@localhost/secondbrain")
+        # Check if embeddings should be enabled (default: True for v4.2.0)
+        enable_embeddings = os.getenv("ENABLE_EMBEDDINGS", "true").lower() == "true"
         self.service = MemoryServicePostgres(
             connection_string=db_url,
-            enable_embeddings=False  # Disabled by default for performance
+            enable_embeddings=enable_embeddings  # Enabled by default for v4.2.0 vector search
         )
         self._initialized = False
 
@@ -41,7 +43,8 @@ async def create_memory(
         memory_type: str = "generic",
         importance_score: float = 0.5,
         tags: List[str] = None,
-        metadata: Dict[str, Any] = None
+        metadata: Dict[str, Any] = None,
+        generate_embedding: bool = True
     ) -> Dict[str, Any]:
         """Create a new memory"""
         await self.initialize()
@@ -51,7 +54,7 @@ async def create_memory(
             importance_score=importance_score,
             tags=tags,
             metadata=metadata,
-            generate_embedding=False
+            generate_embedding=generate_embedding
         )
 
     async def get_memory(self, memory_id: str) -> Optional[Dict[str, Any]]:
@@ -65,7 +68,8 @@ async def update_memory(
         content: Optional[str] = None,
         importance_score: Optional[float] = None,
         tags: Optional[List[str]] = None,
-        metadata: Optional[Dict[str, Any]] = None
+        metadata: Optional[Dict[str, Any]] = None,
+        regenerate_embedding: bool = False
     ) -> Optional[Dict[str, Any]]:
         """Update a memory"""
         await self.initialize()
@@ -74,7 +78,8 @@ async def update_memory(
             content=content,
             importance_score=importance_score,
             tags=tags,
-            metadata=metadata
+            metadata=metadata,
+            regenerate_embedding=regenerate_embedding
         )
 
     async def delete_memory(self, memory_id: str) -> bool:

app/services/memory_service_postgres.py

@@ -264,6 +264,7 @@ async def search_memories(
                     query=query,
                     embedding=embedding,
                     limit=limit,
+                    vector_weight=0.5,  # Default weight
                     min_score=min_score
                 )
 

app/storage/postgres_unified.py

@@ -126,7 +126,8 @@ async def create_memory(
             embedding_generated_at = None
 
             if embedding:
-                embedding_vector = np.array(embedding).tolist()
+                # Convert embedding to PostgreSQL vector format
+                embedding_vector = self._format_vector(embedding)
                 embedding_model = memory.get("embedding_model", "text-embedding-ada-002")
                 embedding_generated_at = datetime.utcnow()
 
@@ -202,7 +203,9 @@ async def update_memory(
         if new_embedding:
             param_count += 1
             set_clauses.append(f"embedding = ${param_count}::vector")
-            params.append(np.array(new_embedding).tolist())
+            # Convert embedding to PostgreSQL vector format
+            embedding_vector = self._format_vector(new_embedding)
+            params.append(embedding_vector)
 
             param_count += 1
             set_clauses.append(f"embedding_generated_at = ${param_count}")
@@ -322,7 +325,7 @@ async def vector_search(
         async with self.acquire() as conn:
             rows = await conn.fetch(
                 query,
-                np.array(embedding).tolist(),
+                self._format_vector(embedding),
                 container_id,
                 min_similarity,
                 limit
@@ -390,7 +393,7 @@ async def hybrid_search(
             rows = await conn.fetch(
                 query_sql,
                 query,
-                np.array(embedding).tolist(),
+                self._format_vector(embedding),
                 limit,
                 vector_weight,
                 min_score
@@ -620,7 +623,7 @@ async def record_search(
             await conn.execute(
                 query_sql,
                 query,
-                np.array(embedding).tolist() if embedding else None,
+                self._format_vector(embedding) if embedding else None,
                 results_count,
                 [uuid.UUID(sid) for sid in selected_ids],
                 search_type,
@@ -660,6 +663,10 @@ async def migrate_from_sqlite(self, sqlite_path: str):
 
     # ==================== Helper Methods ====================
 
+    def _format_vector(self, embedding: List[float]) -> str:
+        """Convert embedding list to PostgreSQL vector format"""
+        return f"[{','.join(str(x) for x in embedding)}]"
+    
     def _row_to_dict(self, row: asyncpg.Record) -> Dict[str, Any]:
         """Convert database row to dictionary"""
         if not row:

scripts/create_hybrid_search.sql

@@ -0,0 +1,76 @@
+-- Create hybrid search function for v4.2.0
+CREATE OR REPLACE FUNCTION hybrid_search(
+    query_text TEXT,
+    query_embedding vector(1536),
+    result_limit INTEGER DEFAULT 10,
+    vector_weight FLOAT DEFAULT 0.5,
+    min_score FLOAT DEFAULT 0.0
+)
+RETURNS TABLE (
+    id UUID,
+    content TEXT,
+    memory_type VARCHAR,
+    importance_score FLOAT,
+    tags TEXT[],
+    metadata JSONB,
+    created_at TIMESTAMPTZ,
+    similarity_score FLOAT,
+    text_rank FLOAT,
+    combined_score FLOAT
+) AS $$
+BEGIN
+    RETURN QUERY
+    WITH vector_search AS (
+        SELECT 
+            m.id,
+            m.content,
+            m.memory_type,
+            m.importance_score,
+            m.tags,
+            m.metadata,
+            m.created_at,
+            1 - (m.embedding <=> query_embedding) AS similarity_score
+        FROM memories m
+        WHERE m.deleted_at IS NULL 
+            AND m.embedding IS NOT NULL
+        ORDER BY m.embedding <=> query_embedding
+        LIMIT result_limit * 2
+    ),
+    text_search AS (
+        SELECT 
+            m.id,
+            m.content,
+            m.memory_type,
+            m.importance_score,
+            m.tags,
+            m.metadata,
+            m.created_at,
+            ts_rank(m.content_tsvector, plainto_tsquery('english', query_text)) AS text_rank
+        FROM memories m
+        WHERE m.deleted_at IS NULL 
+            AND m.content_tsvector @@ plainto_tsquery('english', query_text)
+        ORDER BY text_rank DESC
+        LIMIT result_limit * 2
+    ),
+    combined AS (
+        SELECT 
+            COALESCE(v.id, t.id) AS id,
+            COALESCE(v.content, t.content) AS content,
+            COALESCE(v.memory_type, t.memory_type) AS memory_type,
+            COALESCE(v.importance_score, t.importance_score) AS importance_score,
+            COALESCE(v.tags, t.tags) AS tags,
+            COALESCE(v.metadata, t.metadata) AS metadata,
+            COALESCE(v.created_at, t.created_at) AS created_at,
+            COALESCE(v.similarity_score, 0) AS similarity_score,
+            COALESCE(t.text_rank, 0) AS text_rank,
+            (COALESCE(v.similarity_score, 0) * vector_weight + 
+             COALESCE(t.text_rank, 0) * (1 - vector_weight)) AS combined_score
+        FROM vector_search v
+        FULL OUTER JOIN text_search t ON v.id = t.id
+    )
+    SELECT * FROM combined
+    WHERE combined.combined_score >= min_score
+    ORDER BY combined.combined_score DESC
+    LIMIT result_limit;
+END;
+$$ LANGUAGE plpgsql;