Spaces:

BelikanM
/

kibali-api

Paused

App Files Files Community

lojol469-cmd commited on 24 days ago

Commit

93aade3

1 Parent(s): f3a56a5

Déploiement de l'API Kibali avec Docker

Browse files

Files changed (6) hide show

Dockerfile +17 -26
kibali-ui/index.html +10 -4
kibali-ui/public/kibali_logo.svg +48 -0
kibali-ui/public/manifest.json +15 -0
kibali-ui/public/vite.svg +0 -1
main.py +70 -110

Dockerfile CHANGED Viewed

@@ -1,18 +1,13 @@
-# --- STAGE 1 : Build du Frontend ---
-FROM node:18-alpine AS build-frontend
-WORKDIR /app/frontend
-COPY kibali-ui/package*.json ./
-RUN npm install
-COPY kibali-ui/ ./
-RUN npm run build
-# --- STAGE 2 : Backend (Base NVIDIA Blackwell Compatible) ---
-# On utilise une base 12.6 qui supporte les drivers de la série 50
-FROM nvidia/cuda:12.6.1-runtime-ubuntu22.04
 WORKDIR /app
 ENV DEBIAN_FRONTEND=noninteractive
 RUN apt-get update && apt-get install -y \
     python3-pip \
     python3-dev \
@@ -20,27 +15,23 @@ RUN apt-get update && apt-get install -y \
     git \
     && rm -rf /var/lib/apt/lists/*
-# INSTALLATION PYTORCH NIGHTLY CUDA 13.0
-# C'est ici qu'on débloque le support sm_120
 RUN pip3 install --no-cache-dir --upgrade pip
-RUN pip3 install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu130
-# Installation du reste des dépendances
 COPY requirements.txt .
 RUN pip3 install --no-cache-dir -r requirements.txt
-# On force une version récente de transformers pour le tokenizer Blackwell
-RUN pip3 install --upgrade transformers accelerate bitsandbytes
-COPY --from=build-frontend /app/frontend/dist ./static
 COPY . .
-RUN mkdir -p /app/model_cache
-ENV LD_LIBRARY_PATH=/usr/local/cuda/lib64:$LD_LIBRARY_PATH
-ENV PYTHONUNBUFFERED=1
-ENV MODEL_PATH=/app/model_cache
-EXPOSE 8000
-CMD ["python3", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

+# Utilisation d'une base CUDA optimisée pour les performances
+FROM nvidia/cuda:12.4.1-runtime-ubuntu22.04
 WORKDIR /app
 ENV DEBIAN_FRONTEND=noninteractive
+ENV PYTHONUNBUFFERED=1
+ENV MODEL_PATH=/app/model_cache
+# Installation des dépendances système
 RUN apt-get update && apt-get install -y \
     python3-pip \
     python3-dev \
     git \
     && rm -rf /var/lib/apt/lists/*
+# Installation de PyTorch et des bibliothèques de calcul
 RUN pip3 install --no-cache-dir --upgrade pip
+RUN pip3 install --no-cache-dir torch torchvision torchaudio
+# Copie et installation des dépendances Python
 COPY requirements.txt .
 RUN pip3 install --no-cache-dir -r requirements.txt
+RUN pip3 install --upgrade transformers accelerate bitsandbytes sentence-transformers faiss-cpu
+# Copie de tout le projet (incluant tools/, static/, etc.)
 COPY . .
+# Création des dossiers nécessaires avec les bons droits
+RUN mkdir -p /app/model_cache /app/static /app/data && chmod -R 777 /app
+# Port imposé par Hugging Face Spaces
+EXPOSE 7860
+# Lancement de l'API sur le port 7860
+CMD ["python3", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

kibali-ui/index.html CHANGED Viewed

@@ -1,13 +1,19 @@
 <!doctype html>
-<html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>kibali-ui</title>
   </head>
   <body>
     <div id="root"></div>
     <script type="module" src="/src/main.jsx"></script>
   </body>
-</html>

 <!doctype html>
+<html lang="fr">
   <head>
     <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/kibali_logo.svg?v=2" />
+    <link rel="apple-touch-icon" href="/kibali_logo.svg?v=2" />
+    <link rel="manifest" href="/manifest.json?v=2" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta name="theme-color" content="#7c3aed" /> <title>Kibali AI</title>
   </head>
   <body>
     <div id="root"></div>
     <script type="module" src="/src/main.jsx"></script>
   </body>
+</html>

kibali-ui/public/kibali_logo.svg ADDED Viewed

kibali-ui/public/manifest.json ADDED Viewed

	@@ -0,0 +1,15 @@

+{
+  "short_name": "Kibali",
+  "name": "Kibali AI Assistant",
+  "icons": [
+    {
+      "src": "/kibali_logo.svg",
+      "type": "image/svg+xml",
+      "sizes": "512x512"
+    }
+  ],
+  "start_url": ".",
+  "display": "standalone",
+  "theme_color": "#000000",
+  "background_color": "#ffffff"
+}

kibali-ui/public/vite.svg DELETED Viewed

main.py CHANGED Viewed

@@ -54,20 +54,25 @@ app.add_middleware(
     allow_headers=["*"],
 )
-# --- CHARGEMENT DES MODÈLES ---
-MODEL_PATH = os.getenv("MODEL_PATH", "./model_cache")
-logger.info(f"Utilisation du chemin modèle : {MODEL_PATH}")
 logger.info("Chargement du modèle d'embedding...")
-# Utilisation du cache_folder pour que SentenceTransformer stocke aussi dans le volume partagé
-embed_model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2', cache_folder=MODEL_PATH)
-logger.info("Chargement du tokenizer et du modèle LLM...")
-# Suppression de local_files_only=True pour permettre la compatibilité initiale avec nouvelles architectures GPU
-tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
 if tokenizer.pad_token is None:
     tokenizer.pad_token = tokenizer.eos_token
 bnb_config = BitsAndBytesConfig(
     load_in_4bit=True,
     bnb_4bit_use_double_quant=True,
@@ -75,25 +80,30 @@ bnb_config = BitsAndBytesConfig(
     bnb_4bit_compute_dtype=torch.float16
 )
-model = AutoModelForCausalLM.from_pretrained(
-    MODEL_PATH,
-    quantization_config=bnb_config,
-    device_map="auto",
-    torch_dtype=torch.float16,
-    trust_remote_code=True,
-    low_cpu_mem_usage=True
-)
-logger.info(f"Modèle chargé sur {model.device}")
 # --- BASES VECTORIELLES GLOBALES ---
 dimension = 384
 doc_index = faiss.IndexFlatL2(dimension)
 doc_chunks: List[str] = []
-doc_metadata: List[dict] = []  # Métadonnées des chunks (source, timestamp, etc.)
 memory_index = faiss.IndexFlatL2(dimension)
 memory_texts: List[str] = []
-memory_metadata: List[dict] = []  # Métadonnées des mémoires (timestamp, sujet, score)
 # --- GESTION DU CONTEXTE CONVERSATIONNEL ---
 class ConversationContext:
@@ -103,15 +113,13 @@ class ConversationContext:
         self.subject_start_time = None
         self.message_count = 0
         self.subject_keywords = []
     def update_subject(self, message: str, embedding: np.ndarray):
-        """Détecte et met à jour le sujet actuel de la conversation"""
         keywords = self._extract_keywords(message)
-        # Détection de changement de sujet
         if self.subject_embedding is not None:
             similarity = np.dot(embedding.flatten(), self.subject_embedding.flatten())
-            if similarity < 0.6:  # Seuil de changement de sujet
                 logger.info(f"Changement de sujet détecté (similarité: {similarity:.2f})")
                 self._archive_current_subject()
                 self.current_subject = message
@@ -122,26 +130,23 @@ class ConversationContext:
             else:
                 self.message_count += 1
                 self.subject_keywords.extend(keywords)
-                self.subject_keywords = list(set(self.subject_keywords))[:10]  # Top 10
         else:
             self.current_subject = message
             self.subject_embedding = embedding
             self.subject_start_time = datetime.now()
             self.message_count = 1
             self.subject_keywords = keywords
     def _extract_keywords(self, text: str) -> List[str]:
-        """Extrait les mots-clés importants du texte"""
-        stopwords = {'le', 'la', 'les', 'un', 'une', 'des', 'de', 'du', 'et', 'ou',
                      'est', 'sont', 'à', 'au', 'en', 'pour', 'dans', 'sur', 'avec'}
         words = text.lower().split()
         keywords = [w for w in words if len(w) > 3 and w not in stopwords]
         return keywords[:5]
     def _archive_current_subject(self):
-        """Archive le sujet actuel avant de passer au suivant"""
         if self.current_subject and memory_index.ntotal > 0:
-            # Créer un résumé du sujet archivé
             summary = {
                 "subject": self.current_subject[:200],
                 "keywords": self.subject_keywords,
@@ -202,16 +207,12 @@ def chunk_text(text: str, chunk_size: int = 400, overlap: int = 50) -> List[str]
     return chunks
 def add_to_memory_realtime(user_msg: str, ai_response: str, subject_keywords: List[str]):
-    """Ajoute une entrée mémoire en temps réel avec métadonnées enrichies"""
     timestamp = datetime.now().isoformat()
-    # Créer une entrée mémoire enrichie
     memory_entry = f"""[{timestamp}]
 Sujet: {', '.join(subject_keywords)}
 Utilisateur: {user_msg}
 Kibali: {ai_response}"""
-    # Métadonnées
     metadata = {
         "timestamp": timestamp,
         "subject_keywords": subject_keywords,
@@ -219,61 +220,45 @@ Kibali: {ai_response}"""
         "ai_length": len(ai_response),
         "hash": hashlib.md5(memory_entry.encode()).hexdigest()
     }
-    # Éviter les doublons
     if metadata["hash"] not in [m.get("hash") for m in memory_metadata]:
         memory_texts.append(memory_entry)
         memory_metadata.append(metadata)
-        # Ajout vectoriel
         mem_emb = embed_model.encode([memory_entry], normalize_embeddings=True).astype('float32')
         memory_index.add(mem_emb)
         logger.info(f"Mémoire ajoutée en temps réel: {subject_keywords} (total: {len(memory_texts)})")
         return True
     return False
 def retrieve_adaptive_memory(query: str, k: int = 5) -> tuple:
-    """Récupère la mémoire de façon adaptative selon le contexte"""
     if memory_index.ntotal == 0:
         return [], []
     query_emb = embed_model.encode([query], normalize_embeddings=True).astype('float32')
-    # Recherche de base
-    k_search = min(k * 2, memory_index.ntotal)  # Chercher plus pour filtrer ensuite
     D, I = memory_index.search(query_emb, k=k_search)
-    # Filtrage intelligent avec scoring
     results = []
     for dist, idx in zip(D[0], I[0]):
         if 0 <= idx < len(memory_texts):
             metadata = memory_metadata[idx] if idx < len(memory_metadata) else {}
-            # Score de pertinence
             recency_score = 1.0 / (1 + (datetime.now() - datetime.fromisoformat(metadata.get("timestamp", datetime.now().isoformat()))).seconds / 3600)
             similarity_score = 1.0 / (1 + dist)
-            # Bonus si les mots-clés du sujet actuel correspondent
             keyword_bonus = 0
             if conversation_ctx.subject_keywords:
                 text_lower = memory_texts[idx].lower()
                 keyword_bonus = sum(1 for kw in conversation_ctx.subject_keywords if kw in text_lower) * 0.1
             total_score = similarity_score * 0.6 + recency_score * 0.3 + keyword_bonus
             results.append({
                 "text": memory_texts[idx],
                 "score": total_score,
                 "metadata": metadata
             })
-    # Trier par score et prendre les top k
     results = sorted(results, key=lambda x: x["score"], reverse=True)[:k]
     texts = [r["text"] for r in results]
     scores = [r["score"] for r in results]
     return texts, scores
 # --- ROUTES ---
@@ -295,18 +280,17 @@ async def chat(request: ChatRequest):
     user_message = request.messages[-1].content.strip()
     if not user_message:
         raise HTTPException(status_code=400, detail="Message vide")
     geo = {
         "latitude": request.latitude,
         "longitude": request.longitude,
         "city": request.city or "Libreville"
     }
-    # Mise à jour du contexte conversationnel en temps réel
     user_emb = embed_model.encode([user_message], normalize_embeddings=True).astype('float32')
     conversation_ctx.update_subject(user_message, user_emb)
-    # 1. RAG Documents PDF
     rag_context = ""
     rag_sources = []
     if doc_index.ntotal > 0 and len(doc_chunks) > 0:
@@ -319,72 +303,62 @@ async def chat(request: ChatRequest):
                     rag_sources.append(doc_metadata[idx].get("source", "PDF"))
         if relevant_chunks:
             rag_context = "\n\n".join([f"Document : {chunk}" for chunk in relevant_chunks])
-    # 2. Mémoire conversationnelle adaptative
     memory_context = ""
     memory_texts_filtered, memory_scores = retrieve_adaptive_memory(user_message, k=5)
     if memory_texts_filtered:
-        memory_context = "\n\n".join([f"Mémoire (score: {score:.2f}): {text}"
                                       for text, score in zip(memory_texts_filtered, memory_scores)])
-        logger.info(f"Mémoire récupérée: {len(memory_texts_filtered)} entrées (scores: {[f'{s:.2f}' for s in memory_scores]})")
-    # 3. Réflexion stratégique
     if request.thinking_mode:
         execute_reflection_plan(
-            user_message,
             geo_info=geo,
             messages=request.messages,
             current_subject=conversation_ctx.current_subject,
             subject_keywords=conversation_ctx.subject_keywords
         )
-    # 4. Recherche Web enrichie
     search_query = user_message
     if conversation_ctx.subject_keywords:
         search_query = f"{user_message} {' '.join(conversation_ctx.subject_keywords[:3])} Gabon"
     search_results = web_search(search_query)
     web_context = "\n".join([f"- {r['content'][:500]}" for r in search_results.get("results", [])[:6]])
     web_images = search_results.get("images", [])[:4]
-    # 5. Prompt enrichi avec verrouillage contextuel
     system_prompt = f"""Tu es Kibali, un assistant IA chaleureux, précis et expert du Gabon, basé à {geo['city']}.
 Réponds toujours en français, de façon naturelle, concise et factuelle.
 CONTEXTE CONVERSATIONNEL ACTUEL:
 - Sujet en cours: {', '.join(conversation_ctx.subject_keywords) if conversation_ctx.subject_keywords else 'Nouveau sujet'}
 - Nombre de messages sur ce sujet: {conversation_ctx.message_count}
 PRIORITÉ DES SOURCES:
 1. Documents uploadés (PDF Vault) - Source la plus fiable
 2. Mémoire conversationnelle récente et pertinente
 3. Informations Web actualisées
 Si une information vient d'un document uploadé, mentionne-le brièvement.
 Adapte-toi aux changements brusques de sujet en restant cohérent."""
     full_prompt = f"""### INSTRUCTIONS STRICTES :
 {system_prompt}
 ### CONTEXTE DOCUMENTS (PDF Vault) :
 {rag_context if rag_context else "Aucun document pertinent trouvé."}
 ### HISTORIQUE PERTINENT (Mémoire adaptative) :
 {memory_context if memory_context else "Pas d'historique pertinent."}
 ### INFORMATIONS WEB RÉCENTES :
 {web_context if web_context else "Pas d'informations web disponibles."}
 ### QUESTION :
 {user_message}
 ### RÉPONSE (en français uniquement) :
 """
     inputs = tokenizer(full_prompt, return_tensors="pt", truncation=True, max_length=8192).to(model.device)
     streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True, timeout=120.0)
     def generate_stream():
         try:
             model.generate(
@@ -400,25 +374,23 @@ Adapte-toi aux changements brusques de sujet en restant cohérent."""
             )
         except Exception as e:
             logger.error(f"Erreur génération : {e}")
     thread = Thread(target=generate_stream)
     thread.start()
     response_text = ""
     for new_text in streamer:
         if new_text is not None:
             response_text += new_text
     response_text = response_text.strip()
-    # Ajout en temps réel à la mémoire
     if response_text:
         add_to_memory_realtime(
-            user_message,
-            response_text,
             conversation_ctx.subject_keywords
         )
-    # Informations contextuelles
     context_info = {
         "subject_keywords": conversation_ctx.subject_keywords,
         "message_count": conversation_ctx.message_count,
@@ -426,31 +398,25 @@ Adapte-toi aux changements brusques de sujet en restant cohérent."""
         "rag_sources": list(set(rag_sources)),
         "web_results": len(search_results.get("results", []))
     }
     return ChatResponse(response=response_text, images=web_images, context_info=context_info)
 @app.post("/upload")
 async def upload(files: List[UploadFile] = File(...)):
     total_added = 0
     processed_files = 0
     for file in files:
         if not file.filename.lower().endswith(".pdf"):
             continue
         try:
             content = await file.read()
             text = extract_text_from_pdf(content)
             if not text:
                 logger.warning(f"Aucun texte extrait de {file.filename}")
                 continue
             chunks = chunk_text(text)
             if not chunks:
                 continue
-            # Métadonnées pour chaque chunk
             timestamp = datetime.now().isoformat()
             for chunk in chunks:
                 doc_metadata.append({
@@ -458,19 +424,14 @@ async def upload(files: List[UploadFile] = File(...)):
                     "timestamp": timestamp,
                     "length": len(chunk)
                 })
             embeddings = embed_model.encode(chunks, normalize_embeddings=True).astype('float32')
             doc_index.add(embeddings)
             doc_chunks.extend(chunks)
             total_added += len(chunks)
             processed_files += 1
             logger.info(f"Upload réussi : {file.filename} → {len(chunks)} chunks ajoutés")
         except Exception as e:
             logger.error(f"Erreur lors du traitement de {file.filename} : {e}")
     return {
         "status": "success",
         "files_processed": processed_files,
@@ -484,7 +445,6 @@ async def upload_pdfs(files: List[UploadFile] = File(...)):
 @app.post("/clear-memory")
 async def clear_memory():
-    """Efface la mémoire conversationnelle"""
     global memory_index, memory_texts, memory_metadata
     memory_index = faiss.IndexFlatL2(dimension)
     memory_texts = []
@@ -495,6 +455,6 @@ async def clear_memory():
 # --- DEMARRAGE ---
 @app.on_event("startup")
 async def startup_event():
-    logger.info("🚀 Kibali AI API démarrée avec succès !")
-    logger.info(f"Accès : http://localhost:8000 | Docs : http://localhost:8000/docs")
     logger.info(f"Mémoire adaptative et réflexion contextuelle activées ✓")

     allow_headers=["*"],
 )
+# --- CHARGEMENT DES MODÈLES (téléchargement depuis Hugging Face Hub) ---
+HF_MODEL_ID = "BelikanM/kibali-final-merged"
+CACHE_DIR = "/data/cache"  # Dossier persistant sur HF Spaces
+os.makedirs(CACHE_DIR, exist_ok=True)
 logger.info("Chargement du modèle d'embedding...")
+embed_model = SentenceTransformer(
+    'paraphrase-multilingual-MiniLM-L12-v2',
+    cache_folder=CACHE_DIR
+)
+logger.info(f"Chargement du tokenizer et du modèle LLM depuis Hugging Face : {HF_MODEL_ID}")
+tokenizer = AutoTokenizer.from_pretrained(HF_MODEL_ID, cache_dir=CACHE_DIR)
 if tokenizer.pad_token is None:
     tokenizer.pad_token = tokenizer.eos_token
+# Configuration 4-bit pour réduire la consommation VRAM
 bnb_config = BitsAndBytesConfig(
     load_in_4bit=True,
     bnb_4bit_use_double_quant=True,
     bnb_4bit_compute_dtype=torch.float16
 )
+try:
+    model = AutoModelForCausalLM.from_pretrained(
+        HF_MODEL_ID,
+        quantization_config=bnb_config,
+        device_map="auto",
+        torch_dtype=torch.float16,
+        trust_remote_code=True,
+        low_cpu_mem_usage=True,
+        cache_dir=CACHE_DIR
+    )
+    logger.info(f"Modèle chargé avec succès sur {model.device}")
+except Exception as e:
+    logger.error(f"Erreur lors du chargement du modèle : {e}")
+    raise e
 # --- BASES VECTORIELLES GLOBALES ---
 dimension = 384
 doc_index = faiss.IndexFlatL2(dimension)
 doc_chunks: List[str] = []
+doc_metadata: List[dict] = []
 memory_index = faiss.IndexFlatL2(dimension)
 memory_texts: List[str] = []
+memory_metadata: List[dict] = []
 # --- GESTION DU CONTEXTE CONVERSATIONNEL ---
 class ConversationContext:
         self.subject_start_time = None
         self.message_count = 0
         self.subject_keywords = []
     def update_subject(self, message: str, embedding: np.ndarray):
         keywords = self._extract_keywords(message)
         if self.subject_embedding is not None:
             similarity = np.dot(embedding.flatten(), self.subject_embedding.flatten())
+            if similarity < 0.6:
                 logger.info(f"Changement de sujet détecté (similarité: {similarity:.2f})")
                 self._archive_current_subject()
                 self.current_subject = message
             else:
                 self.message_count += 1
                 self.subject_keywords.extend(keywords)
+                self.subject_keywords = list(set(self.subject_keywords))[:10]
         else:
             self.current_subject = message
             self.subject_embedding = embedding
             self.subject_start_time = datetime.now()
             self.message_count = 1
             self.subject_keywords = keywords
     def _extract_keywords(self, text: str) -> List[str]:
+        stopwords = {'le', 'la', 'les', 'un', 'une', 'des', 'de', 'du', 'et', 'ou',
                      'est', 'sont', 'à', 'au', 'en', 'pour', 'dans', 'sur', 'avec'}
         words = text.lower().split()
         keywords = [w for w in words if len(w) > 3 and w not in stopwords]
         return keywords[:5]
     def _archive_current_subject(self):
         if self.current_subject and memory_index.ntotal > 0:
             summary = {
                 "subject": self.current_subject[:200],
                 "keywords": self.subject_keywords,
     return chunks
 def add_to_memory_realtime(user_msg: str, ai_response: str, subject_keywords: List[str]):
     timestamp = datetime.now().isoformat()
     memory_entry = f"""[{timestamp}]
 Sujet: {', '.join(subject_keywords)}
 Utilisateur: {user_msg}
 Kibali: {ai_response}"""
     metadata = {
         "timestamp": timestamp,
         "subject_keywords": subject_keywords,
         "ai_length": len(ai_response),
         "hash": hashlib.md5(memory_entry.encode()).hexdigest()
     }
     if metadata["hash"] not in [m.get("hash") for m in memory_metadata]:
         memory_texts.append(memory_entry)
         memory_metadata.append(metadata)
         mem_emb = embed_model.encode([memory_entry], normalize_embeddings=True).astype('float32')
         memory_index.add(mem_emb)
         logger.info(f"Mémoire ajoutée en temps réel: {subject_keywords} (total: {len(memory_texts)})")
         return True
     return False
 def retrieve_adaptive_memory(query: str, k: int = 5) -> tuple:
     if memory_index.ntotal == 0:
         return [], []
     query_emb = embed_model.encode([query], normalize_embeddings=True).astype('float32')
+    k_search = min(k * 2, memory_index.ntotal)
     D, I = memory_index.search(query_emb, k=k_search)
     results = []
     for dist, idx in zip(D[0], I[0]):
         if 0 <= idx < len(memory_texts):
             metadata = memory_metadata[idx] if idx < len(memory_metadata) else {}
             recency_score = 1.0 / (1 + (datetime.now() - datetime.fromisoformat(metadata.get("timestamp", datetime.now().isoformat()))).seconds / 3600)
             similarity_score = 1.0 / (1 + dist)
             keyword_bonus = 0
             if conversation_ctx.subject_keywords:
                 text_lower = memory_texts[idx].lower()
                 keyword_bonus = sum(1 for kw in conversation_ctx.subject_keywords if kw in text_lower) * 0.1
             total_score = similarity_score * 0.6 + recency_score * 0.3 + keyword_bonus
             results.append({
                 "text": memory_texts[idx],
                 "score": total_score,
                 "metadata": metadata
             })
     results = sorted(results, key=lambda x: x["score"], reverse=True)[:k]
     texts = [r["text"] for r in results]
     scores = [r["score"] for r in results]
     return texts, scores
 # --- ROUTES ---
     user_message = request.messages[-1].content.strip()
     if not user_message:
         raise HTTPException(status_code=400, detail="Message vide")
     geo = {
         "latitude": request.latitude,
         "longitude": request.longitude,
         "city": request.city or "Libreville"
     }
     user_emb = embed_model.encode([user_message], normalize_embeddings=True).astype('float32')
     conversation_ctx.update_subject(user_message, user_emb)
+    # RAG Documents PDF
     rag_context = ""
     rag_sources = []
     if doc_index.ntotal > 0 and len(doc_chunks) > 0:
                     rag_sources.append(doc_metadata[idx].get("source", "PDF"))
         if relevant_chunks:
             rag_context = "\n\n".join([f"Document : {chunk}" for chunk in relevant_chunks])
+    # Mémoire adaptative
     memory_context = ""
     memory_texts_filtered, memory_scores = retrieve_adaptive_memory(user_message, k=5)
     if memory_texts_filtered:
+        memory_context = "\n\n".join([f"Mémoire (score: {score:.2f}): {text}"
                                       for text, score in zip(memory_texts_filtered, memory_scores)])
+    # Réflexion stratégique
     if request.thinking_mode:
         execute_reflection_plan(
+            user_message,
             geo_info=geo,
             messages=request.messages,
             current_subject=conversation_ctx.current_subject,
             subject_keywords=conversation_ctx.subject_keywords
         )
+    # Recherche Web
     search_query = user_message
     if conversation_ctx.subject_keywords:
         search_query = f"{user_message} {' '.join(conversation_ctx.subject_keywords[:3])} Gabon"
     search_results = web_search(search_query)
     web_context = "\n".join([f"- {r['content'][:500]}" for r in search_results.get("results", [])[:6]])
     web_images = search_results.get("images", [])[:4]
+    # Prompt final
     system_prompt = f"""Tu es Kibali, un assistant IA chaleureux, précis et expert du Gabon, basé à {geo['city']}.
 Réponds toujours en français, de façon naturelle, concise et factuelle.
 CONTEXTE CONVERSATIONNEL ACTUEL:
 - Sujet en cours: {', '.join(conversation_ctx.subject_keywords) if conversation_ctx.subject_keywords else 'Nouveau sujet'}
 - Nombre de messages sur ce sujet: {conversation_ctx.message_count}
 PRIORITÉ DES SOURCES:
 1. Documents uploadés (PDF Vault) - Source la plus fiable
 2. Mémoire conversationnelle récente et pertinente
 3. Informations Web actualisées
 Si une information vient d'un document uploadé, mentionne-le brièvement.
 Adapte-toi aux changements brusques de sujet en restant cohérent."""
     full_prompt = f"""### INSTRUCTIONS STRICTES :
 {system_prompt}
 ### CONTEXTE DOCUMENTS (PDF Vault) :
 {rag_context if rag_context else "Aucun document pertinent trouvé."}
 ### HISTORIQUE PERTINENT (Mémoire adaptative) :
 {memory_context if memory_context else "Pas d'historique pertinent."}
 ### INFORMATIONS WEB RÉCENTES :
 {web_context if web_context else "Pas d'informations web disponibles."}
 ### QUESTION :
 {user_message}
 ### RÉPONSE (en français uniquement) :
 """
     inputs = tokenizer(full_prompt, return_tensors="pt", truncation=True, max_length=8192).to(model.device)
     streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True, timeout=120.0)
     def generate_stream():
         try:
             model.generate(
             )
         except Exception as e:
             logger.error(f"Erreur génération : {e}")
     thread = Thread(target=generate_stream)
     thread.start()
     response_text = ""
     for new_text in streamer:
         if new_text is not None:
             response_text += new_text
     response_text = response_text.strip()
     if response_text:
         add_to_memory_realtime(
+            user_message,
+            response_text,
             conversation_ctx.subject_keywords
         )
     context_info = {
         "subject_keywords": conversation_ctx.subject_keywords,
         "message_count": conversation_ctx.message_count,
         "rag_sources": list(set(rag_sources)),
         "web_results": len(search_results.get("results", []))
     }
     return ChatResponse(response=response_text, images=web_images, context_info=context_info)
 @app.post("/upload")
 async def upload(files: List[UploadFile] = File(...)):
     total_added = 0
     processed_files = 0
     for file in files:
         if not file.filename.lower().endswith(".pdf"):
             continue
         try:
             content = await file.read()
             text = extract_text_from_pdf(content)
             if not text:
                 logger.warning(f"Aucun texte extrait de {file.filename}")
                 continue
             chunks = chunk_text(text)
             if not chunks:
                 continue
             timestamp = datetime.now().isoformat()
             for chunk in chunks:
                 doc_metadata.append({
                     "timestamp": timestamp,
                     "length": len(chunk)
                 })
             embeddings = embed_model.encode(chunks, normalize_embeddings=True).astype('float32')
             doc_index.add(embeddings)
             doc_chunks.extend(chunks)
             total_added += len(chunks)
             processed_files += 1
             logger.info(f"Upload réussi : {file.filename} → {len(chunks)} chunks ajoutés")
         except Exception as e:
             logger.error(f"Erreur lors du traitement de {file.filename} : {e}")
     return {
         "status": "success",
         "files_processed": processed_files,
 @app.post("/clear-memory")
 async def clear_memory():
     global memory_index, memory_texts, memory_metadata
     memory_index = faiss.IndexFlatL2(dimension)
     memory_texts = []
 # --- DEMARRAGE ---
 @app.on_event("startup")
 async def startup_event():
+    logger.info("🚀 Kibali AI API démarrée avec succès sur Hugging Face Spaces !")
+    logger.info(f"Accès : https://your-username-your-space.hf.space | Docs : /docs")
     logger.info(f"Mémoire adaptative et réflexion contextuelle activées ✓")