feat: implement Long-Term Semantic Memory using Qdrant (Approach B)

app/api/routes/analysis.py

@@ -74,6 +74,7 @@ async def start_project_analysis(
         if not current_user.id.hex.startswith("0000"):
             user_repo.deduct_credits(current_user, 50)
             
+        request.user_id = str(current_user.id)
         target_project_id = project_id
         
         # If project_id is the "nil" UUID from frontend, use/create a real project for history
@@ -279,6 +280,7 @@ async def get_specific_analysis(
             engine = K2ThinkEngine()
             k2_request = K2AnalysisRequest(
                 documents=docs,
+                user_id=str(current_user.id),
                 reasoning_depth=depth,
                 ethics_rigor=rigor,
                 info_density=density
@@ -366,7 +368,8 @@ async def scientific_chat(
         result = await engine.chat(
             message=request.message,
             analysis_context=context,
-            history=request.history or []
+            history=request.history or [],
+            user_id=str(current_user.id)
         )
         # Update credits in result
         if isinstance(result, ChatResponse):

app/models/schemas.py

@@ -118,6 +118,7 @@ class ExperimentalProtocol(BaseModel):
 class AnalysisRequest(BaseModel):
     """Requête d'analyse scientifique"""
     documents: List[ScientificDocument]
+    user_id: Optional[str] = None
     user_notes: Optional[str] = None
     
     # Scientific Settings from UI

app/services/k2_think_engine.py

@@ -34,6 +34,9 @@ class K2ThinkEngine:
         
         self.audit_logs: List[AuditLog] = []
         self.reasoning_trace: List[Dict[str, Any]] = []
+        
+        from app.services.memory_service import MemoryService
+        self.memory_service = MemoryService()
     
     async def process_analysis_request(
         self,
@@ -98,9 +101,22 @@ class K2ThinkEngine:
 
             density_instruction = "Use compact, dense bullet points." if request.info_density == "compact" else "Use comfortable, explanatory paragraphs where needed."
 
+            # ============ LONG-TERM SEMANTIC MEMORY ============
+            past_context_instruction = ""
+            if request.user_id:
+                # Search for past memories related to the document titles/content
+                query = f"Research related to: {', '.join([d.title for d in request.documents[:3]])}"
+                memories = await self.memory_service.search_memory(request.user_id, query)
+                
+                if memories:
+                    logger.info(f"K2 Think: Retrieved {len(memories)} past memories for user {request.user_id}")
+                    memories_text = "\n- ".join(memories)
+                    past_context_instruction = f"\n\nPAST RESEARCH CONTEXT & PREFERENCES (Your memory of this researcher):\n- {memories_text}"
+
             system_prompt = f"""You are the K2 Think V2 Scientific Co-Investigator. 
 Your core capability and primary directive is MULTI-DOCUMENT REASONING and KNOWLEDGE SYNTHESIS.
 Do NOT just summarize individual papers. You MUST cross-reference, compare, and contrast the provided documents to uncover deeper strategic insights.
+{past_context_instruction}
 
 REASONING GUIDELINES:
 - DEPTH: {depth_instruction}
@@ -204,6 +220,20 @@ OUTPUT FORMAT: You MUST respond ONLY with a valid JSON object matching this stru
             )
             
             logger.info(f"Analysis {request_id} completed successfully")
+            
+            # ============ MEMORY CONSOLIDATION ============
+            if request.user_id:
+                try:
+                    # Determine project_id (this might need to be passed in the request or handled by orchestration)
+                    # For now we use a generic placeholder if not available
+                    await self.memory_service.consolidate_analysis(
+                        user_id=request.user_id,
+                        project_id="auto_consolidation",
+                        analysis_result=result
+                    )
+                except Exception as mem_err:
+                    logger.error(f"Failed to consolidate memory: {mem_err}")
+                    
             return result
             
         except Exception as e:
@@ -217,7 +247,8 @@ OUTPUT FORMAT: You MUST respond ONLY with a valid JSON object matching this stru
         self,
         message: str,
         analysis_context: Optional[Dict[str, Any]] = None,
-        history: List[Dict[str, str]] = []
+        history: List[Dict[str, str]] = [],
+        user_id: Optional[str] = None
     ) -> Dict[str, Any]:
         """
         Discussion interactive avec K2 Think sur l'analyse
@@ -234,6 +265,13 @@ Your goal:
 
 Keep your tone professional, strategic, and scientifically rigorous.
 """
+        # ============ LONG-TERM SEMANTIC MEMORY (CHAT) ============
+        if user_id:
+            memories = await self.memory_service.search_memory(user_id, message)
+            if memories:
+                memories_text = "\n- ".join(memories)
+                system_prompt += f"\n\nPAST USER CONTEXT (Relevant to this query):\n- {memories_text}"
+
         messages = [{"role": "system", "content": system_prompt}]
         
         # Add history

app/services/memory_service.py

@@ -0,0 +1,146 @@
+"""
+Service de Mémoire Sémantique - Persistance du savoir de l'investigateur via Qdrant
+"""
+from typing import List, Dict, Any, Optional
+from qdrant_client import QdrantClient
+from qdrant_client.http import models
+from app.core.settings import settings
+from app.core.logging import logger
+from datetime import datetime
+import uuid
+
+class MemoryService:
+    """
+    Gère la mémoire à long terme de l'agent.
+    Stocke les découvertes, préférences et conclusions passées.
+    """
+    
+    COLLECTION_NAME = "user_semantic_memory"
+    
+    def __init__(self):
+        self.client = QdrantClient(
+            url=settings.VECTOR_DB_URL,
+            api_key=settings.VECTOR_DB_API_KEY
+        )
+        self._ensure_collection()
+
+    def _ensure_collection(self):
+        """Crée la collection si elle n'existe pas"""
+        try:
+            collections = self.client.get_collections().collections
+            exists = any(c.name == self.COLLECTION_NAME for c in collections)
+            
+            if not exists:
+                logger.info(f"Creating Qdrant collection: {self.COLLECTION_NAME}")
+                self.client.create_collection(
+                    collection_name=self.COLLECTION_NAME,
+                    vectors_config=models.VectorParams(
+                        size=1536, # Taille standard OpenAI embeddings (text-embedding-3-small)
+                        distance=models.Distance.COSINE
+                    )
+                )
+        except Exception as e:
+            logger.error(f"Failed to ensure Qdrant collection: {e}")
+
+    async def save_memory(self, user_id: str, content: str, metadata: Dict[str, Any] = None):
+        """Sauvegarde un fragment de savoir dans la mémoire sémantique"""
+        from openai import AsyncOpenAI
+        openai_client = AsyncOpenAI(api_key=settings.OPENAI_API_KEY)
+        
+        try:
+            # 1. Générer embedding
+            response = await openai_client.embeddings.create(
+                input=content,
+                model="text-embedding-3-small"
+            )
+            embedding = response.data[0].embedding
+            
+            # 2. Upsert dans Qdrant
+            point_id = str(uuid.uuid4())
+            payload = {
+                "user_id": user_id,
+                "content": content,
+                "created_at": datetime.utcnow().isoformat(),
+                **(metadata or {})
+            }
+            
+            self.client.upsert(
+                collection_name=self.COLLECTION_NAME,
+                points=[
+                    models.PointStruct(
+                        id=point_id,
+                        vector=embedding,
+                        payload=payload
+                    )
+                ]
+            )
+            logger.info(f"Memory fragment saved for user {user_id}")
+            return point_id
+        except Exception as e:
+            logger.error(f"Failed to save memory: {e}")
+            return None
+
+    async def search_memory(self, user_id: str, query: str, limit: int = 5) -> List[str]:
+        """Recherche des souvenirs pertinents pour un sujet donné"""
+        from openai import AsyncOpenAI
+        openai_client = AsyncOpenAI(api_key=settings.OPENAI_API_KEY)
+        
+        try:
+            # 1. Générer embedding de la requête
+            response = await openai_client.embeddings.create(
+                input=query,
+                model="text-embedding-3-small"
+            )
+            embedding = response.data[0].embedding
+            
+            # 2. Rechercher dans Qdrant filtré par user_id
+            search_result = self.client.search(
+                collection_name=self.COLLECTION_NAME,
+                query_vector=embedding,
+                query_filter=models.Filter(
+                    must=[
+                        models.FieldCondition(
+                            key="user_id",
+                            match=models.MatchValue(value=user_id)
+                        )
+                    ]
+                ),
+                limit=limit
+            )
+            
+            memories = [hit.payload["content"] for hit in search_result if hit.score > 0.7]
+            return memories
+        except Exception as e:
+            logger.error(f"Failed to search memory: {e}")
+            return []
+
+    async def consolidate_analysis(self, user_id: str, project_id: str, analysis_result: Any):
+        """
+        Génère un résumé des points clés d'une analyse et les stocke en mémoire.
+        """
+        # Note: On utilise K2 pour générer le résumé sémantique si nécessaire
+        # Pour le hackathon, on peut extraire les recommandations stratégiques et les gaps clés
+        
+        summary_parts = []
+        if hasattr(analysis_result, 'reasoning_summary') and analysis_result.reasoning_summary:
+            summary_parts.append(analysis_result.reasoning_summary)
+            
+        if hasattr(analysis_result, 'strategic_recommendations') and analysis_result.strategic_recommendations:
+            recs = ". ".join(analysis_result.strategic_recommendations)
+            summary_parts.append(f"Strategic Findings: {recs}")
+            
+        if not summary_parts:
+            return
+            
+        full_context = "\n".join(summary_parts)
+        
+        # On peut demander à K2 de "condenser" cela en savoir réutilisable
+        # Mais pour aller vite, on stocke le bloc tel quel ou par petits morceaux
+        await self.save_memory(
+            user_id=user_id,
+            content=full_context,
+            metadata={
+                "project_id": project_id,
+                "type": "analysis_consolidation"
+            }
+        )