fix: Add chat method to K2ThinkEngine for scientific_chat route

HF_PRIVATE_BACKEND.md

@@ -0,0 +1,202 @@
+# 🔒 Rapport : Mise en Privé du Backend Hugging Face Space
+
+**Date** : 21 juin 2026  
+**Projet** : AI Scientific Co-Investigator  
+**Backend HF Space** : `dama12-scientific-backend.hf.space`  
+**Frontend** : Next.js — `ai-scientific-coinvestigator-frontend`
+
+---
+
+## 1. Contexte
+
+Le backend FastAPI est actuellement déployé sur Hugging Face Spaces en mode **public**. L'objectif est de le passer en **privé** pour améliorer la sécurité, tout en maintenant l'accès depuis le frontend Next.js.
+
+---
+
+## 2. État actuel du Frontend
+
+### Fichiers clés analysés
+
+| Fichier | Rôle |
+|---------|------|
+| [`src/lib/api/client.ts`](file:///c:/Users/user/Desktop/ai-scientific-coinvestigator-frontend/src/lib/api/client.ts) | Client Axios centralisé — **seul fichier à modifier** |
+| [`.env.local`](file:///c:/Users/user/Desktop/ai-scientific-coinvestigator-frontend/.env.local) | Variables d'environnement locales |
+| [`.env.example`](file:///c:/Users/user/Desktop/ai-scientific-coinvestigator-frontend/.env.example) | Template de configuration |
+
+### Architecture actuelle des appels API
+
+```
+Frontend (Next.js)
+    │
+    ├── axios instance (client.ts)
+    │       ├── baseURL → NEXT_PUBLIC_API_URL (HF Space public)
+    │       └── intercepteur → ajoute JWT user en Authorization header
+    │
+    └── → Backend HF Space (public, aucune restriction)
+```
+
+### Gestion d'auth déjà présente
+
+Le frontend gère déjà un token JWT pour authentifier les **utilisateurs de l'app** :
+
+```typescript
+// client.ts — intercepteur existant
+apiClient.interceptors.request.use((config) => {
+  const token = localStorage.getItem('token');  // JWT user
+  if (token && config.headers) {
+    config.headers.Authorization = `Bearer ${token}`;
+  }
+  return config;
+});
+```
+
+---
+
+## 3. Ce que change un Space Privé HF
+
+Quand un Hugging Face Space est en **privé** :
+
+- ❌ Tout appel HTTP sans token HF valide reçoit une **erreur 401**
+- ✅ Les appels avec `Authorization: Bearer hf_xxxxx` fonctionnent normalement
+- ✅ L'API du Space reste identique — seule l'authentification d'accès change
+
+> [!IMPORTANT]
+> Le token HF requis pour accéder au Space **privé** est différent du JWT JWT applicatif utilisé pour authentifier les users de l'app. Ce sont deux niveaux d'authentification distincts.
+
+---
+
+## 4. Problème : Conflit de Headers
+
+Le frontend utilise déjà `Authorization: Bearer <JWT>` pour l'auth utilisateur.  
+Le Space privé HF exige `Authorization: Bearer <hf_token>` pour l'accès.
+
+**Deux approches pour résoudre ce conflit :**
+
+### Option A — Header custom HF (Recommandée ✅)
+
+Hugging Face accepte le header `Authorization` standard pour son token.  
+On peut utiliser un header séparé côté backend pour ne pas interférer.
+
+```
+Frontend → HF Space : Authorization: Bearer hf_xxxx  (accès au Space)
+Frontend → App API : X-User-Token: Bearer <JWT>       (auth utilisateur)
+```
+
+Mais cela **nécessite de modifier le backend** pour lire le JWT depuis un header custom.
+
+---
+
+### Option B — Proxy Next.js (Recommandée ✅ si pas de modif backend)
+
+Créer des **API Routes Next.js** comme proxy intermédiaire :
+
+```
+Navigateur → Next.js API Route → HF Space (avec token HF en secret serveur)
+```
+
+Avantages :
+- Le token HF n'est **jamais exposé** côté client (secret serveur)
+- Le JWT user est géré séparément par le Next.js proxy
+- Aucune modification backend requise
+
+```typescript
+// pages/api/proxy/[...path].ts (NOUVEAU)
+export default async function handler(req, res) {
+  const response = await fetch(`${process.env.HF_SPACE_URL}${req.url}`, {
+    headers: {
+      'Authorization': `Bearer ${process.env.HF_TOKEN}`,  // secret serveur
+      'X-User-Token': req.headers['x-user-token'],         // JWT user transmis
+    },
+  });
+  // ...
+}
+```
+
+---
+
+### Option C — Token HF côté client (Simple mais risquée ⚠️)
+
+Injecter le token HF directement dans les headers du client Axios :
+
+```typescript
+// client.ts modifié
+const apiClient = axios.create({
+  headers: {
+    'Content-Type': 'application/json',
+    'X-HF-Space-Token': process.env.NEXT_PUBLIC_HF_TOKEN,  // exposé !
+  },
+});
+```
+
+> [!WARNING]
+> `NEXT_PUBLIC_*` variables sont **visibles dans le bundle JS** du navigateur. Le token HF serait exposé publiquement — cela ne sécurise pas vraiment l'accès.
+
+---
+
+## 5. Tableau Comparatif des Options
+
+| Critère | Option A (Header custom) | Option B (Proxy Next.js) | Option C (Client-side) |
+|---------|--------------------------|--------------------------|------------------------|
+| Sécurité du token HF | ✅ Serveur | ✅ Serveur | ❌ Exposé client |
+| Modif backend requise | ✅ Oui | ❌ Non | ❌ Non |
+| Complexité | Moyenne | Moyenne | Faible |
+| WebSocket (WSS) supporté | ✅ | ⚠️ Complexe | ✅ |
+| Recommandation | Si backend accessible | **Meilleure option** | À éviter |
+
+---
+
+## 6. Impact sur les WebSockets
+
+Le frontend utilise aussi `NEXT_PUBLIC_WS_URL=wss://dama12-scientific-backend.hf.space`.
+
+> [!CAUTION]
+> Les WebSockets dans un Space HF privé **ne supportent pas** le header `Authorization` standard (limitation du protocole WS). Il faudra passer le token HF en **query parameter** lors de la connexion WS :
+> ```
+> wss://dama12-scientific-backend.hf.space?token=hf_xxxx
+> ```
+> Ce qui expose aussi le token dans les logs. À évaluer selon l'usage réel des WebSockets dans l'app.
+
+---
+
+## 7. Plan d'Action Recommandé
+
+```
+Étape 1 — Rendre le Space privé sur HF
+   └── Settings → Space visibility → Private
+
+Étape 2 — Générer un token HF dédié
+   └── HF Settings → Access Tokens → New token (role: read)
+
+Étape 3 — Implémenter le Proxy Next.js (Option B)
+   ├── Créer pages/api/proxy/[...path].ts
+   ├── Ajouter HF_TOKEN dans .env.local (variable serveur, sans NEXT_PUBLIC_)
+   └── Modifier client.ts pour pointer vers /api/proxy/ au lieu de HF directement
+
+Étape 4 — Gérer les WebSockets
+   └── Évaluer si les WS sont utilisés activement et adapter si nécessaire
+
+Étape 5 — Tests
+   └── Vérifier tous les endpoints via le proxy
+```
+
+---
+
+## 8. Fichiers à Créer / Modifier
+
+| Action | Fichier | Effort |
+|--------|---------|--------|
+| **CRÉER** | `src/pages/api/proxy/[...path].ts` | ~40 lignes |
+| **MODIFIER** | `src/lib/api/client.ts` | ~3 lignes |
+| **MODIFIER** | `.env.local` | +1 variable |
+| **MODIFIER** | `.env.example` | +1 variable |
+
+**Effort estimé : 1-2 heures**
+
+---
+
+## 9. Conclusion
+
+> [!NOTE]
+> La mise en privé du backend HF est **totalement faisable** sans modifier le backend. L'Option B (Proxy Next.js) est la plus sécurisée et la plus propre car elle garde le token HF côté serveur et ne change pas l'architecture existante du backend.
+
+Le principal risque est lié aux **WebSockets** si ils sont utilisés en production — à vérifier avant l'implémentation.

app/services/k2_think_engine.py

@@ -491,6 +491,134 @@ class K2ThinkEngine:
                 logger.critical(f"Even fallback generation failed: {fallback_err}")
                 raise ValueError(f"Analysis failed with error: {str(e)[:200]}.") from e
 
+    async def chat(
+        self,
+        message: str,
+        analysis_context: Optional[Dict[str, Any]],
+        history: List[Dict[str, str]],
+        user_id: str
+    ) -> "ChatResponse":
+        """
+        Interactive scientific chat using K2 Think API.
+        Answers user questions grounded in the provided analysis context.
+        """
+        from app.models.schemas import ChatResponse
+
+        # Build context summary from analysis result
+        context_summary = ""
+        if analysis_context:
+            reasoning = analysis_context.get("reasoning_summary", "")
+            recommendations = analysis_context.get("strategic_recommendations", [])
+            gaps = []
+            comp = analysis_context.get("comparative_analysis") or {}
+            for g in (analysis_context.get("research_gaps") or comp.get("research_gaps") or []):
+                if isinstance(g, dict):
+                    gaps.append(g.get("gap_description") or g.get("description") or "")
+                elif isinstance(g, str):
+                    gaps.append(g)
+            contradictions = []
+            for c in (comp.get("contradictions") or []):
+                if isinstance(c, dict):
+                    contradictions.append(c.get("description") or c.get("conflict") or "")
+                elif isinstance(c, str):
+                    contradictions.append(c)
+            common_findings = comp.get("common_findings") or []
+
+            context_parts = []
+            if reasoning:
+                context_parts.append(f"[ANALYSIS SUMMARY]\n{reasoning}")
+            if common_findings:
+                context_parts.append("[COMMON FINDINGS]\n" + "\n".join(f"- {f}" for f in common_findings[:5]))
+            if gaps:
+                context_parts.append("[RESEARCH GAPS]\n" + "\n".join(f"- {g}" for g in gaps[:5] if g))
+            if contradictions:
+                context_parts.append("[CONTRADICTIONS / CONFLICTS]\n" + "\n".join(f"- {c}" for c in contradictions[:3] if c))
+            if recommendations:
+                context_parts.append("[STRATEGIC RECOMMENDATIONS]\n" + "\n".join(f"- {r}" for r in recommendations[:5]))
+            context_summary = "\n\n".join(context_parts)
+
+        # Build conversation history for the prompt
+        history_text = ""
+        if history:
+            history_lines = []
+            for turn in history[-8:]:  # keep last 8 turns to stay within token limits
+                role = turn.get("role", "user")
+                content = turn.get("content", "")
+                prefix = "User" if role == "user" else "Assistant"
+                history_lines.append(f"{prefix}: {content}")
+            history_text = "\n".join(history_lines)
+
+        # Retrieve relevant memories if available
+        memory_context = ""
+        try:
+            memories = await self.memory_service.search_memory(
+                user_id=user_id,
+                query=message,
+                limit=3
+            )
+            if memories:
+                memory_context = "[RELEVANT MEMORY]\n" + "\n".join(
+                    f"- {m}" for m in memories if m
+                )
+        except Exception as mem_err:
+            logger.warning(f"Memory retrieval failed during chat: {mem_err}")
+
+        system_prompt = """You are K2, an expert AI scientific co-investigator. You have access to the results of a deep comparative analysis of scientific papers. Your role is to answer the user's questions in a precise, insightful, and scientifically rigorous manner, always grounding your answers in the analysis context provided.
+
+If the user asks about a specific paper, summarise it from the context. If they ask for experimental design help, leverage the identified research gaps and recommendations. Keep answers concise but substantive. Reply in the same language as the user's question."""
+
+        user_prompt_parts = []
+        if context_summary:
+            user_prompt_parts.append(f"[ANALYSIS CONTEXT]\n{context_summary}")
+        if memory_context:
+            user_prompt_parts.append(memory_context)
+        if history_text:
+            user_prompt_parts.append(f"[CONVERSATION HISTORY]\n{history_text}")
+        user_prompt_parts.append(f"[USER QUESTION]\n{message}")
+
+        full_prompt = system_prompt + "\n\n" + "\n\n".join(user_prompt_parts)
+
+        chat_config = {
+            "model": "MBZUAI-IFM/K2-Think-v2",
+            "openai_api_key": settings.K2_THINK_API_KEY,
+            "openai_api_base": settings.K2_THINK_API_URL,
+            "timeout": 120,
+            "max_retries": 1,
+        }
+
+        try:
+            llm = ChatOpenAI(**chat_config)
+            response = await llm.ainvoke([HumanMessage(content=full_prompt)])
+            raw_answer = response.content if hasattr(response, "content") else str(response)
+
+            # Strip any <think>...</think> reasoning block from the visible answer
+            visible_answer = re.sub(r"<think>.*?</think>", "", raw_answer, flags=re.DOTALL).strip()
+            reasoning_log = ""
+            think_match = re.search(r"<think>(.*?)</think>", raw_answer, flags=re.DOTALL)
+            if think_match:
+                reasoning_log = think_match.group(1).strip()
+
+            # Suggested follow-up actions
+            suggested_actions = [
+                "Explore this further",
+                "Generate a targeted protocol",
+                "Identify related research gaps",
+            ]
+
+            self._record_api_success()
+            logger.info("Chat response generated by K2 Think Engine")
+
+            return ChatResponse(
+                answer=visible_answer or raw_answer,
+                reasoning_log=reasoning_log or "K2 Think reasoning applied.",
+                suggested_actions=suggested_actions,
+            )
+
+        except Exception as e:
+            self._record_api_failure()
+            logger.error(f"K2 chat API call failed: {e}")
+            raise
+
     def _generate_fallback_analysis_result(
         self,
         request_id: str,