Update app.py

app.py

@@ -20,6 +20,21 @@ import PyPDF2
 from io import BytesIO
 import uuid
 
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from sklearn.metrics.pairwise import cosine_similarity
+import time
+
+# Ajoutez ces imports au début du fichier
+from fastapi.responses import StreamingResponse
+import json
+import asyncio
+
+
+from langchain_community.document_loaders import PyPDFDirectoryLoader
+from langchain_text_splitters import RecursiveCharacterTextSplitter
+from langchain_community.embeddings import HuggingFaceEmbeddings
+
+
 SECRET_KEY = secrets.token_hex(32)  
 
 HOST = os.environ.get("API_URL", "0.0.0.0")
@@ -38,6 +53,9 @@ db_name = os.environ.get("DB_NAME", "chatmed_schizo")
 mongo_client = MongoClient(mongo_uri)
 db = mongo_client[db_name]
 
+SAVE_FOLDER = "files"
+COLLECTION_NAME="connaissances"
+os.makedirs(SAVE_FOLDER, exist_ok=True)
 
 
 app = FastAPI()
@@ -56,6 +74,95 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+def download_pdf(url, save_path, retries=2, delay=3):
+    for attempt in range(retries):
+        try:
+            req = Request(url, headers={'User-Agent': 'Mozilla/5.0'})
+            with urlopen(req) as response, open(save_path, 'wb') as f:
+                f.write(response.read())
+            print(f"Téléchargé : {save_path}")
+            return
+        except (HTTPError, URLError) as e:
+            print(f"Erreur ({e}) pour {url}, tentative {attempt+1}/{retries}")
+            time.sleep(delay)
+    print(f"Échec du téléchargement : {url}")
+
+'''
+Le chargement automatique des PDFs est désactivé. La base de données utilise les embeddings existants.
+for url in PDF_URLS:
+    file_name = url.split("/")[-1]
+    file_path = os.path.join(SAVE_FOLDER, file_name)
+    if not os.path.exists(file_path):
+        download_pdf(url, file_path)
+
+loader = PyPDFDirectoryLoader(SAVE_FOLDER)
+docs = loader.load()
+
+splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
+chunks = splitter.split_documents(docs)
+print(f"{len(chunks)} morceaux extraits.")
+
+embedding_model = HuggingFaceEmbeddings(model_name="shtilev/medical_embedded_v2")
+
+client = MongoClient(MONGO_URI)
+collection = client[DB_NAME][COLLECTION_NAME]
+
+collection.delete_many({})
+
+for chunk in chunks:
+    text = chunk.page_content
+    embedding = embedding_model.embed_query(text)
+    collection.insert_one({
+        "text": text,
+        "embedding": embedding
+    })
+
+print("Tous les embeddings ont été insérés dans la base MongoDB.")
+'''
+
+
+
+
+def retrieve_relevant_context(query, embedding_model, mongo_collection, k=5):
+    query_embedding = embedding_model.embed_query(query)
+    
+    docs = list(mongo_collection.find({}, {"text": 1, "embedding": 1}))
+    
+    # Format pour affichage de debug
+    print(f"[DEBUG] Recherche de contexte pour: '{query}'")
+    print(f"[DEBUG] {len(docs)} documents trouvés dans la base de données")
+    
+    # Si pas de documents, retourner chaîne vide
+    if not docs:
+        print("[DEBUG] Aucun document dans la collection. RAG désactivé.")
+        return ""
+    
+    # Calcul des similarités
+    similarities = []
+    for i, doc in enumerate(docs):
+        if "embedding" not in doc or not doc["embedding"]:
+            print(f"[DEBUG] Document {i} sans embedding")
+            continue
+            
+        sim = cosine_similarity([query_embedding], [doc["embedding"]])[0][0]
+        similarities.append((sim, i, doc["text"]))
+    
+    # Trier par similarité décroissante
+    similarities.sort(reverse=True)
+    
+    # Afficher les top k documents avec leurs scores
+    print("\n=== CONTEXTE SÉLECTIONNÉ ===")
+    top_k_docs = []
+    for i, (score, idx, text) in enumerate(similarities[:k]):
+        doc_preview = text[:100] + "..." if len(text) > 100 else text
+        print(f"Document #{i+1} (score: {score:.4f}): {doc_preview}")
+        top_k_docs.append(text)
+    print("==========================\n")
+    
+    # Retourner le texte joint
+    return "\n\n".join(top_k_docs)
+
+
 
 async def get_admin_user(request: Request):
     user = await get_current_user(request)
@@ -66,10 +173,24 @@ async def get_admin_user(request: Request):
 
 # Initialiser le modèle d'embedding (à faire une seule fois au démarrage)
 try:
-    embedder = SentenceTransformer('all-MiniLM-L6-v2')
+    embedding_model = HuggingFaceEmbeddings(model_name="shtilev/medical_embedded_v2")
+    print("✅ Modèle d'embedding médical chargé avec succès")
+
 except Exception as e:
     print(f"Erreur lors du chargement du modèle d'embedding: {str(e)}")
-    embedder = None
+    embedding_model = None
+
+doc_count = db.connaissances.count_documents({})
+print(f"\n[DIAGNOSTIC] Collection 'connaissances': {doc_count} documents trouvés")
+if doc_count == 0:
+    print("[AVERTISSEMENT] La collection est vide. Le système RAG ne fonctionnera pas!")
+    print("[AVERTISSEMENT] Veuillez charger des documents via l'API admin ou exécuter le script d'initialisation.")
+else:
+    sample_doc = db.connaissances.find_one({})
+    has_embeddings = "embedding" in sample_doc and sample_doc["embedding"] is not None
+    print(f"[DIAGNOSTIC] Les documents ont des embeddings: {'✅ Oui' if has_embeddings else '❌ Non'}")
+    if not has_embeddings:
+        print("[AVERTISSEMENT] Les documents n'ont pas d'embeddings valides!")
 @app.post("/api/admin/knowledge/upload")
 async def upload_pdf(
     file: UploadFile = File(...),
@@ -358,33 +479,322 @@ async def invert(text: str):
 HF_TOKEN = os.getenv('REACT_APP_HF_TOKEN')
 if not HF_TOKEN:
     raise RuntimeError("Le token Hugging Face (HF_TOKEN) n'est pas défini dans les variables d'environnement.")
-
+conversation_history = {}
 hf_client = InferenceClient(token=HF_TOKEN)
-
 @app.post("/api/chat")
 async def chat(request: Request):
+    global conversation_history
+    
+    # ① Lecture du JSON et extraction des champs
     data = await request.json()
     user_message = data.get("message", "").strip()
+    conversation_id = data.get("conversation_id")
+
+    # ② Vérification du message utilisateur
     if not user_message:
         raise HTTPException(status_code=400, detail="Le champ 'message' est requis.")
 
+    # ③ Authentification (on continue même si non authentifié)
+    current_user = None
+    try:
+        current_user = await get_current_user(request)
+    except HTTPException:
+        pass
+
+    # ④ Gestion du quota de tokens pour l'utilisateur/authenticated convo
+    current_tokens = 0
+    message_tokens = 0
+    if current_user and conversation_id:
+        conv = db.conversations.find_one({
+            "_id": ObjectId(conversation_id),
+            "user_id": str(current_user["_id"])
+        })
+        if conv:
+            current_tokens = conv.get("token_count", 0)
+        message_tokens = int(len(user_message.split()) * 1.3)
+        MAX_TOKENS = 2000
+        if current_tokens + message_tokens > MAX_TOKENS:
+            return JSONResponse({
+                "error": "token_limit_exceeded",
+                "message": "Cette conversation a atteint sa limite de taille. Veuillez en créer une nouvelle.",
+                "tokens_used": current_tokens,
+                "tokens_limit": MAX_TOKENS
+            }, status_code=403)
+
+    # ⑤ Sauvegarde immédiate du message utilisateur
+    if conversation_id and current_user:
+        db.messages.insert_one({
+            "conversation_id": conversation_id,
+            "user_id": str(current_user["_id"]),
+            "sender": "user",
+            "text": user_message,
+            "timestamp": datetime.utcnow()
+        })
+
+    # ⑥ Détection d'une question sur l'historique
+    is_history_question = any(
+        phrase in user_message.lower()
+        for phrase in [
+            "ma première question", "ma précédente question", "ma dernière question",
+            "ce que j'ai demandé", "j'ai dit quoi", "quelles questions",
+            "c'était quoi ma", "quelle était ma", "mes questions"
+        ]
+    )
+
+    # ⑦ Initialize conversation history if it doesn't exist
+    if conversation_id not in conversation_history:
+        conversation_history[conversation_id] = []
+        # If there's existing conversation in DB, load it to memory
+        if current_user and conversation_id:
+            previous_messages = list(db.messages.find(
+                {"conversation_id": conversation_id}
+            ).sort("timestamp", 1))
+            
+            for msg in previous_messages:
+                if msg["sender"] == "user":
+                    conversation_history[conversation_id].append(f"Question : {msg['text']}")
+                else:
+                    conversation_history[conversation_id].append(f"Réponse : {msg['text']}")
+
+    # ─── Gestion spécialisée des questions d'historique ─────────
+    if is_history_question:
+        # Recueillir les vraies questions (pas les méta-questions sur l'historique)
+        actual_questions = []
+        
+        if conversation_id in conversation_history:
+            for msg in conversation_history[conversation_id]:
+                if msg.startswith("Question : "):
+                    q_text = msg.replace("Question : ", "")
+                    # Ignorer les méta-questions qui parlent déjà de l'historique
+                    is_meta = any(phrase in q_text.lower() for phrase in [
+                        "ma première question", "ma précédente question", "ma dernière question",
+                        "ce que j'ai demandé", "j'ai dit quoi", "quelles questions",
+                        "c'était quoi ma", "quelle était ma", "mes questions"
+                    ])
+                    if not is_meta:
+                        actual_questions.append(q_text)
+        
+        # Cas 1: Aucune question précédente
+        if not actual_questions:
+            return JSONResponse({
+                "response": "Vous n'avez pas encore posé de question dans cette conversation. C'est notre premier échange."
+            })
+        
+        # Détection dynamique du numéro de question demandé
+        question_number = None
+        
+        # Chercher les patterns de questions spécifiques
+        if any(p in user_message.lower() for p in ["première question", "1ère question", "1ere question"]):
+            question_number = 1
+        elif any(p in user_message.lower() for p in ["deuxième question", "2ème question", "2eme question", "seconde question"]):
+            question_number = 2
+        else:
+            import re
+            # Chercher des patterns comme "3ème question", "4e question", etc.
+            match = re.search(r'(\d+)[eèiéê]*m*e* question', user_message.lower())
+            if match:
+                try:
+                    question_number = int(match.group(1))
+                except:
+                    pass
+        
+        # Si on a identifié un numéro de question spécifique
+        if question_number is not None:
+            if 0 < question_number <= len(actual_questions):
+                suffix = "ère" if question_number == 1 else "ème"
+                return JSONResponse({
+                    "response": f"Votre {question_number}{suffix} question était : \"{actual_questions[question_number-1]}\""
+                })
+            else:
+                return JSONResponse({
+                    "response": f"Vous n'avez pas encore posé {question_number} questions dans cette conversation."
+                })
+        
+        # Cas général: liste toutes les questions
+        else:
+            if len(actual_questions) == 1:
+                return JSONResponse({
+                    "response": f"Vous avez posé une seule question jusqu'à présent : \"{actual_questions[0]}\""
+                })
+            else:
+                question_list = "\n".join([f"{i+1}. {q}" for i, q in enumerate(actual_questions)])
+                return JSONResponse({
+                    "response": f"Voici les questions que vous avez posées dans cette conversation :\n\n{question_list}"
+                })
+    # ───────────────────────────────────────────────────────────────
+
+    # ⑧ RAG – récupération de contexte si ce n'est pas une question d'historique
+    context = None
+    if not is_history_question and embedding_model:
+        context = retrieve_relevant_context(user_message, embedding_model, db.connaissances, k=5)
+        # Store context in history
+        if context and conversation_id:
+            conversation_history[conversation_id].append(f"Contexte : {context}")
+
+    # Add current question to history
+    if conversation_id:
+        conversation_history[conversation_id].append(f"Question : {user_message}")
+
+    # ⑨ Construction du prompt système avec contexte enrichi
+    system_prompt = (
+        "Tu es un chatbot spécialisé dans la santé mentale, et plus particulièrement la schizophrénie. "
+        "Tu réponds de façon fiable, claire et empathique, en t'appuyant uniquement sur des sources médicales et en français. "
+    )
+
+    # Construire un contexte enrichi qui combine RAG et résumé de l'historique
+    enriched_context = ""
+
+    # Ajouter un résumé des questions précédentes (maximum 3)
+    if conversation_id in conversation_history:
+        actual_questions = []
+        for msg in conversation_history[conversation_id]:
+            if msg.startswith("Question : "):
+                q_text = msg.replace("Question : ", "")
+                # Ignorer les méta-questions
+                is_meta = any(phrase in q_text.lower() for phrase in [
+                    "ma première question", "ma précédente question", "ma dernière question",
+                    "ce que j'ai demandé", "j'ai dit quoi", "quelles questions",
+                    "c'était quoi ma", "quelle était ma", "mes questions"
+                ])
+                if not is_meta and q_text != user_message:  # Ne pas inclure la question actuelle
+                    actual_questions.append(q_text)
+        
+        # Ajouter les 3 dernières questions au contexte
+        if actual_questions:
+            recent_questions = actual_questions[-5:]  # 3 dernières questions
+            enriched_context += "Historique récent des questions:\n"
+            for i, q in enumerate(recent_questions):
+                enriched_context += f"- Question précédente {len(recent_questions)-i}: {q}\n"
+            enriched_context += "\n"
+
+    # Ajouter le contexte RAG s'il existe
+    if context:
+        enriched_context += "Contexte médical pertinent:\n"
+        enriched_context += context
+        enriched_context += "\n\n"
+
+    # Compléter le prompt système
+    if enriched_context:
+        system_prompt += (
+            f"\n\n{enriched_context}\n\n"
+            "Utilise ces informations pour répondre de manière plus précise et contextuelle. "
+            "Ne pas inventer d'informations. Si tu ne sais pas, redirige vers un professionnel de santé."
+        )
+    else:
+        system_prompt += (
+            "Tu dois répondre uniquement à partir de connaissances médicales factuelles. "
+            "Si tu ne sais pas répondre, indique-le clairement et suggère de consulter un professionnel de santé."
+        )
+
+    # ⑩ Construction de l'historique conversationnel pour le modèle
+    messages = [{"role": "system", "content": system_prompt}]
+    
+    # Format conversation history for the LLM
+    if conversation_id and len(conversation_history.get(conversation_id, [])) > 0:
+        # Convert our history format to chat format (last 10 exchanges)
+        history = conversation_history[conversation_id]
+        for i in range(0, min(20, len(history)-1), 2):
+            if i+1 < len(history):
+                if history[i].startswith("Question :"):
+                    user_text = history[i].replace("Question : ", "")
+                    messages.append({"role": "user", "content": user_text})
+                
+                if history[i+1].startswith("Réponse :"):
+                    assistant_text = history[i+1].replace("Réponse : ", "")
+                    messages.append({"role": "assistant", "content": assistant_text})
+    
+    # Add current user message
+    messages.append({"role": "user", "content": user_message})
+
+    # ⑫ Appel à l'API Hugging Face
     try:
-        response = hf_client.text_generation(
+        completion = hf_client.chat.completions.create(
+            model="mistralai/Mistral-7B-Instruct-v0.3",
+            messages=messages,
+            max_tokens=400, 
+            temperature=0.7, 
+            timeout=15,  
+        )
+        bot_response = completion.choices[0].message["content"].strip()
+    except Exception:
+        fallback = hf_client.text_generation(
             model="mistralai/Mistral-7B-Instruct-v0.3",
-            prompt=f"<s>[INST] Tu es un assistant médical spécialisé en schizophrénie. Réponds à cette question: {user_message} [/INST]",
+            prompt=f"<s>[INST] {system_prompt}\n\nQuestion: {user_message} [/INST]",
             max_new_tokens=512,
             temperature=0.7
         )
+        bot_response = fallback
+
+    # Add bot response to history
+    if conversation_id:
+        conversation_history[conversation_id].append(f"Réponse : {bot_response}")
         
-        return {"response": response}
-    
-    except Exception as e:
-        import traceback
-        print(f"Erreur détaillée: {traceback.format_exc()}")
-        raise HTTPException(status_code=502, detail=f"Erreur d'inférence HF : {str(e)}")
+        # Keep history to a reasonable size
+        if len(conversation_history[conversation_id]) > 50:  # 25 exchanges
+            conversation_history[conversation_id] = conversation_history[conversation_id][-50:]
 
+    # ⑬ Sauvegarde de la réponse de l'assistant + mise à jour tokens & last_message
+    if conversation_id and current_user:
+        db.messages.insert_one({
+            "conversation_id": conversation_id,
+            "user_id": str(current_user["_id"]),
+            "sender": "assistant",
+            "text": bot_response,
+            "timestamp": datetime.utcnow()
+        })
+        response_tokens = int(len(bot_response.split()) * 1.3)
+        total_tokens = current_tokens + message_tokens + response_tokens
+        db.conversations.update_one(
+            {"_id": ObjectId(conversation_id)},
+            {"$set": {
+                "last_message": bot_response,
+                "updated_at": datetime.utcnow(),
+                "token_count": total_tokens
+            }}
+        )
+
+    # ⑭ Retour de la réponse finale
+    return {"response": bot_response}
 
 
+def simulate_token_count(text):
+    """
+    Simule le comptage de tokens sans appeler d'API externe.
+    """
+    if not text:
+        return 0
+    
+    # Prétraitement pour mieux gérer les cas spéciaux
+    text = text.replace('\n', ' \n ')
+    
+    # Compter les caractères spéciaux et espaces
+    spaces_and_punct = sum(1 for c in text if c.isspace() or c in ',.;:!?()[]{}"\'`-_=+<>/@#$%^&*|\\')
+    
+    # Compter les chiffres
+    digits = sum(1 for c in text if c.isdigit())
+    
+    # Compter les mots courts et tokens spéciaux
+    words = text.split()
+    short_words = sum(1 for w in words if len(w) <= 2)
+    
+    # Les URLs et codes consomment plus de tokens
+    code_blocks = len(re.findall(r'```[\s\S]*?```', text))
+    urls = len(re.findall(r'https?://\S+', text))
+    
+    # Longueur restante après ajustements
+    adjusted_length = len(text) - spaces_and_punct - digits - short_words
+    
+    # Calcul final avec facteurs de pondération
+    token_count = (
+        adjusted_length / 4 +
+        spaces_and_punct * 0.25 +
+        digits * 0.5 +
+        short_words * 0.5 +
+        code_blocks * 5 +
+        urls * 4
+    )
+    
+    return int(token_count * 1.1) + 1
 @app.get("/data")
 async def get_data():
     data = {"data": np.random.rand(100).tolist()}
@@ -508,6 +918,7 @@ async def delete_conversation(conversation_id: str, current_user: dict = Depends
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Erreur serveur: {str(e)}")
 
+
 app.mount("/", StaticFiles(directory="static", html=True), name="static")
 
 if __name__ == "__main__":
@@ -515,12 +926,12 @@ if __name__ == "__main__":
 
     print(args)
     uvicorn.run(
-        "app:app",
+        "app2:app",
         host=args.host,
         port=args.port,
         reload=args.reload,
+        
         ssl_certfile=args.ssl_certfile,
         ssl_keyfile=args.ssl_keyfile,
     )
 
-