Forráskód Böngészése

assistant ai version 1

Nadine Elleuch 1 éve
commit
f41ae6c648

+ 0 - 0
__init__.py


BIN
agent_ai/__pycache__/auth.cpython-312.pyc


BIN
agent_ai/__pycache__/chunking.cpython-312.pyc


BIN
agent_ai/__pycache__/embedding_index.cpython-312.pyc


BIN
agent_ai/__pycache__/qa_chain.cpython-312.pyc


BIN
agent_ai/__pycache__/scraping.cpython-312.pyc


BIN
agent_ai/__pycache__/test_auth.cpython-312-pytest-8.4.1.pyc


BIN
agent_ai/__pycache__/test_chunking.cpython-312-pytest-8.4.1.pyc


BIN
agent_ai/__pycache__/test_embedding_index.cpython-312-pytest-8.4.1.pyc


BIN
agent_ai/__pycache__/test_qa_chain.cpython-312-pytest-8.4.1.pyc


BIN
agent_ai/__pycache__/test_scraping.cpython-312-pytest-8.4.1.pyc


+ 43 - 0
agent_ai/auth.py

@@ -0,0 +1,43 @@
+"""
+auth.py 
+
+Gestion de l’authentification sur le wiki Intersel
+
+Ce module permet de se connecter au wiki en utilisant une session HTTP persistante et il récupère tout seul un code spécial (le token CSRF) nécessaire pour se connecter en toute sécurité
+"""
+
+import requests
+from bs4 import BeautifulSoup
+
+session = requests.Session()
+
+def login_to_wiki(username, password):
+    login_url = "https://wiki.intersel.fr/doku.php?id=start&do=login"
+    resp = session.get(login_url)
+    soup = BeautifulSoup(resp.text, "html.parser")
+    sectok_input = soup.find("input", {"name": "sectok"})
+
+    if not sectok_input:
+        print("❌ Impossible de trouver le token CSRF.")
+        return False
+
+    login_data = {
+        "u": username,
+        "p": password,
+        "do": "login",
+        "sectok": sectok_input.get("value")
+    }
+
+    headers = {
+        "User-Agent": "Mozilla/5.0",
+        "Referer": login_url
+    }
+
+    login_resp = session.post(login_url, data=login_data, headers=headers)
+
+    if "logout" in login_resp.text.lower():
+        print("✅ Connexion réussie.")
+        return True
+    else:
+        print("❌ Échec de la connexion.")
+        return False

+ 62 - 0
agent_ai/chunking.py

@@ -0,0 +1,62 @@
+import nltk
+from sklearn.metrics.pairwise import cosine_similarity
+from sentence_transformers import SentenceTransformer
+import numpy as np
+import re
+from typing import List
+
+nltk.download('punkt')
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+MIN_WORDS_PER_CHUNK = 10
+
+def semantic_chunking(sentences, similarity_threshold=0.10, max_words_per_chunk=150):
+    chunks = []
+    current_chunk = []
+    current_embeddings = []
+
+    sentence_embeddings = model.encode(sentences)
+
+    for i, (sentence, embedding) in enumerate(zip(sentences, sentence_embeddings)):
+        sentence = sentence.strip()
+        if not sentence:
+            continue
+
+        word_count = len(sentence.split())
+
+        # Cas de phrase courte qui pourrait être un titre ("Gérant", "Responsable", etc.)
+        if word_count <= 3 and i > 0:
+            # Ajoute à la phrase précédente (cas comme "Gérante")
+            current_chunk.append(sentence)
+            current_embeddings.append(embedding)
+            continue
+
+        if not current_embeddings:
+            current_chunk.append(sentence)
+            current_embeddings.append(embedding)
+        else:
+            mean_embedding = np.mean(current_embeddings, axis=0)
+            sim = cosine_similarity([embedding], [mean_embedding])[0][0]
+
+            if sim > similarity_threshold and len(" ".join(current_chunk).split()) < max_words_per_chunk:
+                current_chunk.append(sentence)
+                current_embeddings.append(embedding)
+            else:
+                chunk_text = " ".join(current_chunk)
+                if len(chunk_text.split()) >= MIN_WORDS_PER_CHUNK:
+                    chunks.append(chunk_text)
+                current_chunk = [sentence]
+                current_embeddings = [embedding]
+
+    if current_chunk:
+        chunk_text = " ".join(current_chunk)
+        if len(chunk_text.split()) >= MIN_WORDS_PER_CHUNK:
+            chunks.append(chunk_text)
+
+    if not chunks:
+        print("⚠️ Aucun chunk généré. Vérifie la structure ou le contenu des phrases.")
+
+    return chunks
+
+
+

+ 43 - 0
agent_ai/embedding_index.py

@@ -0,0 +1,43 @@
+"""
+embedding_index.py
+
+Ce module permet de créer et utiliser un index FAISS pour rechercher rapidement des vecteurs similaires
+
+La fonction build_faiss_index construit un index à partir d’une liste de vecteurs (embeddings) en normalisant les vecteurs pour mesurer la similarité par cosinus
+
+La fonction search_faiss cherche les vecteurs les plus proches d’un vecteur donné (requête) et retourne les distances et positions des meilleurs résultats
+
+"""
+
+import numpy as np
+import faiss
+
+"""
+Construire un index FAISS à partir d'une matrice d'embeddings pour pouvoir faire des recherches rapides par similarité
+"""
+
+def build_faiss_index(embeddings):
+    try:
+        dimension = embeddings.shape[1]
+        index = faiss.IndexFlatL2(dimension)
+        index.add(embeddings)
+        return index
+    except Exception as e:
+        print("Erreur lors de la création de l'index FAISS :", e)
+        raise
+
+
+"""
+Trouver les top_k vecteurs les plus similaires à un vecteur de requête en utilisant la similarité cosinus
+"""
+def search_faiss(index, query_embeddings, top_k=10):
+    query_embeddings = np.asarray(query_embeddings)
+
+    # Assurer la bonne forme
+    if query_embeddings.ndim == 1:
+        query_embeddings = np.expand_dims(query_embeddings, axis=0)
+
+    faiss.normalize_L2(query_embeddings)
+    distances, indices = index.search(query_embeddings, top_k)
+    return distances, indices  # Ne pas extraire [0] si batch
+

+ 32 - 0
agent_ai/qa_chain.py

@@ -0,0 +1,32 @@
+from langchain_ollama import OllamaLLM
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+
+prompt_template = PromptTemplate(
+    input_variables=["context", "question"],
+  template="""
+Tu es un assistant francophone très rigoureux. Tu ne dois **répondre qu’à partir du contexte fourni** ci-dessous.
+
+Contexte :
+{context}
+
+Question :
+{question}
+
+Si la réponse ne peut pas être déduite **mot pour mot** du contexte, dis : "Je ne sais pas."
+
+Réponse :
+"""
+
+
+)
+
+
+def get_qa_chain():
+    llm = OllamaLLM(
+        model="llama3",
+        temperature=0.7,
+        top_p=0.9,
+        max_tokens=256
+    )
+    return LLMChain(llm=llm, prompt=prompt_template)

+ 36 - 0
agent_ai/scraping.py

@@ -0,0 +1,36 @@
+"""
+scraping.py
+
+Récupération du contenu de plusieurs pages web en accédant à leur mode édition
+
+"""
+
+from bs4 import BeautifulSoup
+from agent_ai.auth import session
+
+"""
+Récupère le contenu de plusieurs pages web en accédant à leur mode édition
+"""
+def fetch_all_pages_content(urls):
+    url_texts = {}
+    for url in urls:
+        try:
+            # modifier l'url pour accéder à la version édition de la page 
+            edit_url = url + "&do=edit" if "?" in url else url + "?do=edit"
+            response = session.get(edit_url)
+            if response.status_code == 200:
+                soup = BeautifulSoup(response.text, "html.parser")
+                # Trouver la balise <textarea name="wikitext">
+                textarea = soup.find("textarea", {"name": "wikitext"})
+                if textarea:
+                    raw_text = textarea.text  # Extraire le contenu texte brut
+                    url_texts[url] = raw_text  # Enregistrer dans le dictionnaire
+                else:
+                    print(f"⚠️ Pas de balise <textarea> trouvée pour {edit_url}.")
+            else:
+                print(f"⚠️ Erreur d'accès à {edit_url} : code {response.status_code}")
+        except Exception as e:
+            print(f"❌ Exception pour {url}: {e}")
+    return url_texts
+
+

+ 239 - 0
app.py

@@ -0,0 +1,239 @@
+from flask import Flask, request, jsonify, send_from_directory, Response
+import nltk
+import numpy as np
+import json
+import os
+from sentence_transformers import CrossEncoder, SentenceTransformer
+from langchain_ollama import OllamaLLM
+from agent_ai.auth import login_to_wiki
+from agent_ai.scraping import fetch_all_pages_content
+from agent_ai.chunking import semantic_chunking, model, chunk_text, chunk_text_generic
+from agent_ai.embedding_index import build_faiss_index, search_faiss
+from agent_ai.qa_chain import get_qa_chain
+from tabulate import tabulate
+import textwrap
+
+app = Flask(__name__)
+
+nltk.download('punkt')
+
+# Global state
+state = {
+    "model": model,
+    "cross_encoder": CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2'),
+    "index": None,
+    "all_chunks": [],
+    "chunk_urls": [],
+    "qa_chain": get_qa_chain()
+}
+
+@app.route('/index.html')
+def index():
+    return send_from_directory(os.getcwd(), 'index.html')
+
+@app.route("/login", methods=["POST"])
+def login():
+    data = request.json
+    username = data.get("username")
+    password = data.get("password")
+
+    if not username or not password:
+        return jsonify({"error": "username and password required"}), 400
+
+    if not login_to_wiki(username, password):
+        return jsonify({"error": "Authentication failed"}), 401
+
+    return jsonify({"message": "Login successful"})
+
+@app.route("/fetch_pages", methods=["POST"])
+def fetch_pages():
+    urls = [
+        "https://wiki.intersel.fr/doku.php?id=intersel:presentation_equipe",
+        "https://wiki.intersel.fr/doku.php?id=intersel:presentation",
+        "https://wiki.intersel.fr/doku.php?id=intersel:guides:entretiens:stagiaires",
+        "https://wiki.intersel.fr/doku.php?id=projets:samsic:anticipia:start",
+        "https://wiki.intersel.fr/doku.php?id=intersel:php",
+        "https://wiki.intersel.fr/doku.php?id=produit:developpement:livinweb:documentations:admin_manual:start",
+        "https://wiki.intersel.fr/doku.php?id=intersel:resume_annuaire",
+        "https://wiki.intersel.fr/doku.php?id=technique:developpement:developpement_phplist:start",
+        "https://wiki.intersel.fr/doku.php?id=produit:developpement:livinweb:projets:integration_metronic:start",
+        "https://wiki.intersel.fr/doku.php?id=produit:developpement:livinweb:documentations:dev_manual:start"
+    ]
+    pages = fetch_all_pages_content(urls)
+    raw_pages = [{"url": url, "text": text.strip()} for url, text in pages.items()]
+    
+    with open("raw_pages_pretty.json", "w", encoding="utf-8") as f:
+        json.dump(raw_pages, f, ensure_ascii=False, indent=2)
+    
+    print("📄 Contenu brut des pages enregistré dans 'raw_pages_pretty.json'")
+    return jsonify(raw_pages)
+
+
+state = {
+    "chunk_urls": [],
+    "model": SentenceTransformer("all-MiniLM-L6-v2"), 
+    "cross_encoder": CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")  
+}
+
+
+@app.route("/chunk_all", methods=["POST"]) 
+def chunk_all():
+    data = request.get_json()
+    text = data.get("text", "")
+    url = data.get("url", "url inconnue")
+
+    if not text.strip():
+        return jsonify({"error": "Texte vide"}), 400
+
+    sentences = nltk.sent_tokenize(text, language='french')
+    chunks = semantic_chunking(sentences, similarity_threshold=0.10, max_words_per_chunk=1000)
+    # chunks = chunk_text_generic(text, max_words=500)
+
+    chunk_data = []
+    response_chunks = []
+
+    for i, chunk in enumerate(chunks, start=1):
+        clean_chunk = chunk.strip()
+        word_count = len(clean_chunk.split())
+
+        chunk_data.append({
+            "chunk_id": i,
+            "text": clean_chunk,
+            "url": url,
+            "word_count": word_count
+        })
+        response_chunks.append(clean_chunk)
+
+        # Sécuriser l'état global
+        if "chunk_urls" not in state:
+            state["chunk_urls"] = []
+        state["chunk_urls"].append(url)
+
+    # Enregistrement JSON
+    with open("chunks_pretty.json", "a", encoding="utf-8") as f:
+        for chunk in chunk_data:
+            f.write(json.dumps(chunk, ensure_ascii=False) + ",\n")
+
+    print(f"✅ {len(chunk_data)} chunks enregistrés pour {url}")
+    return jsonify({"chunks": response_chunks})
+
+@app.route("/build_index", methods=["POST"])
+def build_index():
+    data = request.json
+    texts = data.get("texts")
+    urls = data.get("urls")
+
+    if not texts or not isinstance(texts, list):
+        return jsonify({"error": "A list of texts is required"}), 400
+
+    embeddings = state["model"].encode(texts, convert_to_tensor=False)
+    embeddings = np.array(embeddings).astype('float32')
+
+    index = build_faiss_index(embeddings)
+    state["index"] = index
+    state["all_chunks"] = texts
+
+    # Important: also assign the urls to the global state here
+    if urls and isinstance(urls, list) and len(urls) == len(texts):
+        state["chunk_urls"] = urls
+    
+
+    print("✅ Index FAISS construit avec succès")
+    return jsonify({"message": f"Index built with {len(texts)} vectors"})
+
+@app.route("/search_index", methods=["POST"])
+def search_index():
+    data = request.json
+    question = data.get("question")
+
+    if not question:
+        return jsonify({"error": "Question is required"}), 400
+
+    if state["index"] is None:
+        return jsonify({"error": "Index not built yet"}), 400
+
+    question_embedding = state["model"].encode([question], convert_to_tensor=False)
+    question_embedding = np.array(question_embedding).astype('float32')
+
+    if question_embedding.ndim == 1:
+        question_embedding = np.expand_dims(question_embedding, axis=0)
+
+    distances, indices = search_faiss(state["index"], question_embedding, top_k=20)
+
+    faiss_chunks = [state["all_chunks"][i] for i in indices[0]]
+
+    # Re-rank with CrossEncoder
+    cross_encoder = state["cross_encoder"]
+    cross_scores = cross_encoder.predict([(question, chunk) for chunk in faiss_chunks])
+    reranked = sorted(zip(faiss_chunks, indices[0], cross_scores), key=lambda x: x[2], reverse=True)
+
+    top_chunks = [chunk for chunk, _, _ in reranked]
+    indices[0] = [idx for _, idx, _ in reranked]
+
+    state["last_indices"] = indices[0]
+
+    # Display ranked results in a table
+    table = []
+    results = []
+
+    for rank, (chunk, idx, score) in enumerate(reranked, start=1):
+        url = state["chunk_urls"][idx] if idx < len(state["chunk_urls"]) else "URL inconnue"
+
+        # Wrap chunk and URL text to keep it readable in the terminal
+        wrapped_chunk = "\n".join(textwrap.wrap(chunk.strip(), width=80))[:500] + "..."
+        wrapped_url = "\n".join(textwrap.wrap(url, width=80))
+
+        table.append([rank, round(score, 4), wrapped_chunk, wrapped_url])
+        results.append({"text": chunk, "score": float(score), "url": url})
+
+    print("\n================== RÉSULTATS CLASSÉS PAR PERTINENCE ==================")
+    print(tabulate(table, headers=["Rank", "Score", "Chunk", "URL"], tablefmt="fancy_grid"))
+    print("=======================================================================\n")
+
+
+    top_context = " ".join(top_chunks)
+
+    return jsonify({"results": results, "context": top_context})
+
+llm = OllamaLLM(
+    model="llama3",
+    temperature=0.3,
+    top_p=0.9,
+    max_tokens=200
+)
+
+@app.route("/qa_chain", methods=["POST"])
+def qa_chain_route():
+    data = request.get_json()
+    question = data.get("question", "")
+
+    top_chunks = [
+        f"[Source: {state['chunk_urls'][i] if i < len(state['chunk_urls']) else 'URL inconnue'}]\n{state['all_chunks'][i]}"
+        for i in state.get("last_indices", [])
+        if i < len(state["all_chunks"])
+    ]
+    top_context = "\n\n".join(top_chunks)
+
+    # Limit context length to avoid overload
+    max_context_length = 5000
+    if len(top_context) > max_context_length:
+        top_context = top_context[:max_context_length]
+
+    prompt = (
+        "Fournis une réponse factuelle et précise en te basant uniquement sur des informations vérifiables. "
+        "Si tu n'es pas certain de la réponse ou si les données sont ambiguës, indique clairement que l'information n'est pas disponible ou nécessite une vérification. "
+        "Ne fais aucune supposition ou inférence qui pourrait être incorrecte, et précise les sources utilisées lorsque possible.\n\n"
+        f"{top_context}\n\n"
+        f"Question : {question}"
+    )
+
+    result = llm(prompt)
+
+    print("\n====================== PROMPT UTILISÉ ======================")
+    print(f"CONTEXTE :\n{top_context}\nQUESTION :\n{question}\nRÉPONSE :\n{result}")
+    print("============================================================\n")
+
+    return jsonify({"answer": result})
+
+if __name__ == "__main__":
+    app.run(debug=True)

+ 150 - 0
index.html

@@ -0,0 +1,150 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Agent AI </title>
+<style>
+  body { font-family: Arial, sans-serif; max-width: 600px; margin: auto; padding: 20px; }
+  textarea, input, button { width: 100%; margin-bottom: 10px; padding: 8px; box-sizing: border-box; }
+  button { cursor: pointer; }
+  .response { background: #f0f0f0; padding: 10px; white-space: pre-wrap; border: 1px solid #ccc; min-height: 150px; }
+  label { font-weight: bold; }
+</style>
+</head>
+<body>
+
+<h1>Agent AI </h1>
+
+<label for="username">Nom d'utilisateur :</label>
+<input type="text" id="username" placeholder="Entrez votre nom d'utilisateur" />
+
+<label for="password">Mot de passe :</label>
+<input type="password" id="password" placeholder="Entrez votre mot de passe" />
+
+<label for="userQuestion">Ta question :</label>
+<textarea id="userQuestion" rows="4" placeholder="Écris ta question ici..."></textarea>
+
+<button onclick="runFullChain()">Envoyer</button>
+
+<h2>Réponse :</h2>
+<div id="finalResponse" class="response" style="white-space: normal;"></div>
+
+<script>
+async function runFullChain() {
+  const username = document.getElementById('username').value.trim();
+  const password = document.getElementById('password').value.trim();
+  const question = document.getElementById('userQuestion').value.trim();
+
+  if (!username || !password) {
+    alert('Merci d\'entrer votre nom d\'utilisateur et mot de passe.');
+    return;
+  }
+  if (!question) {
+    alert('Merci d\'écrire une question.');
+    return;
+  }
+
+  const finalResponseElem = document.getElementById('finalResponse');
+  finalResponseElem.textContent = 'Chargement...';
+
+  try {
+    // 1. Login
+    const resLogin = await fetch('/login', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({username, password})
+    });
+    if (!resLogin.ok) {
+      const err = await resLogin.json();
+      finalResponseElem.textContent = 'Erreur login: ' + (err.error || resLogin.statusText);
+      return;
+    }
+
+    // 2. Fetch pages
+    const resPages = await fetch('/fetch_pages', { method: 'POST' });
+    if (!resPages.ok) {
+      finalResponseElem.textContent = 'Erreur récupération pages.';
+      return;
+    }
+    const pages = await resPages.json();
+
+    // 3. Chunk
+    let chunks = [];
+    for (const page of pages) {
+      const url = page.url || "url inconnue";
+      const fullText = page.text || "";
+
+      const resChunk = await fetch('/chunk_all', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text: fullText, url: url })
+      });
+
+      if (!resChunk.ok) {
+        console.error(`Erreur découpage texte pour ${url}`);
+        continue;
+      }
+
+      const chunkData = await resChunk.json();
+      chunks.push(...chunkData.chunks);
+    }
+
+    // Extraire les URLs des pages pour la requête build_index
+    const urls = pages.map(p => p.url || "url inconnue");
+
+    // 4. Build index
+    const resIndex = await fetch('/build_index', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({ texts: chunks, urls: urls })  // <-- urls défini ici
+    });
+    if (!resIndex.ok) {
+      finalResponseElem.textContent = 'Erreur création index.';
+      return;
+    }
+
+    // 5. Search index for relevant context
+    const resSearch = await fetch('/search_index', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({ question: question })
+    });
+    if (!resSearch.ok) {
+      finalResponseElem.textContent = 'Erreur recherche dans index.';
+      return;
+    }
+    const searchResults = await resSearch.json();
+
+    // Construire contexte à partir des meilleurs chunks
+    let context = '';
+    for (const r of searchResults.results) {
+      context += `Extrait provenant de : ${r.url}\n${r.text}\n\n`;
+    }
+
+    // 6. QA chain
+    const resQA = await fetch('/qa_chain', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({ context: context, question: question })
+    });
+    if (!resQA.ok) {
+      finalResponseElem.textContent = 'Erreur lors de la réponse.';
+      return;
+    }
+    const qaResult = await resQA.json();
+
+    const rawAnswer = qaResult.answer || 'Aucune réponse obtenue.';
+    const htmlAnswer = marked.parse(rawAnswer);
+    finalResponseElem.innerHTML = htmlAnswer;
+  } catch (e) {
+    finalResponseElem.textContent = 'Erreur interne: ' + e.message;
+  }
+}
+
+</script>
+<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+
+
+</body>
+</html>

+ 40 - 0
requirements.txt

@@ -0,0 +1,40 @@
+beautifulsoup4==4.13.4
+blinker==1.9.0
+certifi==2025.7.14
+charset-normalizer==3.4.2
+click==8.2.1
+colorama==0.4.6
+faiss-cpu==1.11.0.post1
+filelock==3.18.0
+Flask==3.1.1
+fsspec==2025.7.0
+huggingface-hub==0.33.4
+idna==3.10
+itsdangerous==2.2.0
+Jinja2==3.1.6
+joblib==1.5.1
+MarkupSafe==3.0.2
+mpmath==1.3.0
+networkx==3.5
+nltk==3.9.1
+numpy==2.3.1
+packaging==25.0
+pillow==11.3.0
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.4
+safetensors==0.5.3
+scikit-learn==1.7.1
+scipy==1.16.0
+sentence-transformers==5.0.0
+setuptools==80.9.0
+soupsieve==2.7
+sympy==1.14.0
+threadpoolctl==3.6.0
+tokenizers==0.21.2
+torch==2.7.1
+tqdm==4.67.1
+transformers==4.53.3
+typing_extensions==4.14.1
+urllib3==2.5.0
+Werkzeug==3.1.3

BIN
tests/__pycache__/test_auth.cpython-312-pytest-8.4.1.pyc


BIN
tests/__pycache__/test_chunking.cpython-312-pytest-8.4.1.pyc


BIN
tests/__pycache__/test_embedding_index.cpython-312-pytest-8.4.1.pyc


BIN
tests/__pycache__/test_qa_chain.cpython-312-pytest-8.4.1.pyc


BIN
tests/__pycache__/test_scraping.cpython-312-pytest-8.4.1.pyc


+ 46 - 0
tests/test_auth.py

@@ -0,0 +1,46 @@
+import pytest #framework de test
+from unittest.mock import patch # mock est une simulation d’un objet réel que l’on utilise pendant les tests
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from agent_ai.auth import login_to_wiki
+
+@patch("agent_ai.auth.session.get") # remplace temporairement session.get / session.post
+@patch("agent_ai.auth.session.post")
+def test_login_success(mock_post, mock_get):
+    # Mock de la réponse GET avec un token CSRF valide
+    mock_get.return_value.text = '''
+        <html><form>
+            <input type="hidden" name="sectok" value="fake_csrf_token">
+        </form></html>
+    '''
+    # Simule la page de login contenant un token CSRF
+    # Mock de la réponse POST avec indication de succès (présence de 'logout')
+    mock_post.return_value.text = "You are now logged in. <a href='logout'>Logout</a>"
+
+    result = login_to_wiki("fakeuser", "fakepass")
+    assert result == True
+
+@patch("agent_ai.auth.session.get")
+@patch("agent_ai.auth.session.post")
+def test_login_failure(mock_post, mock_get):
+    # Mock de la réponse GET avec un token CSRF valide
+    mock_get.return_value.text = '''
+        <html><form>
+            <input type="hidden" name="sectok" value="fake_csrf_token">
+        </form></html>
+    '''
+
+    # Mock de la réponse POST avec échec (pas de 'logout')
+    mock_post.return_value.text = "Invalid login"
+
+    result = login_to_wiki("fakeuser", "wrongpass")
+    assert result == False
+
+@patch("agent_ai.auth.session.get")
+def test_missing_csrf_token(mock_get):
+    # Simule une page sans le champ CSRF
+    mock_get.return_value.text = "<html><form></form></html>"
+
+    result = login_to_wiki("fakeuser", "fakepass")
+    assert result == False

+ 47 - 0
tests/test_chunking.py

@@ -0,0 +1,47 @@
+from agent_ai.chunking import semantic_chunking  
+import pytest
+
+def test_similar_sentences_grouped():
+    sentences = [
+        "L'intelligence artificielle est en plein essor.",
+        "L'IA transforme de nombreux secteurs.",
+        "Les modèles de langage sont au cœur de cette révolution."
+    ]
+    chunks = semantic_chunking(sentences, similarity_threshold=0.2)
+    assert len(chunks) == 1  # Toutes les phrases sont similaires → 1 chunk
+
+def test_dissimilar_sentences_separated():
+    sentences = [
+        "Paris est la capitale de la France.",
+        "Le moteur de voiture est tombé en panne.",
+        "Python est un langage de programmation populaire.",
+        "La météo aujourd'hui est très ensoleillée avec peu de vent.",
+        "Les baleines migrent chaque année vers des eaux plus chaudes.",
+        "La cuisson du pain nécessite de la patience et une bonne température.",
+        "Le football est l’un des sports les plus pratiqués dans le monde.",
+        "La musique classique a une influence apaisante sur le cerveau.",
+        "Les ordinateurs quantiques représentent l’avenir de la technologie.",
+        "L’astronomie permet d’explorer les mystères de l’univers."
+        ]
+    chunks = semantic_chunking(sentences, similarity_threshold=0.7)
+    assert len(chunks) >= 2  # Elles devraient être séparées
+
+def test_short_sentences_ignored():
+    sentences = [
+        "Ok.",
+        "Bonjour.",
+        "Merci.",
+        "Très bien.",
+        "Ça va."
+    ]
+    chunks = semantic_chunking(sentences)
+    assert len(chunks) == 0  # Trop courtes -> ignorées
+
+def test_min_words_per_chunk_respected():
+    sentences = ["Ceci est une phrase pertinente."] * 20  # Répétition pour atteindre 20+ mots
+    chunks = semantic_chunking(sentences)
+    assert all(len(c.split()) >= 20 for c in chunks)
+
+def test_empty_input():
+    chunks = semantic_chunking([])
+    assert chunks == []

+ 46 - 0
tests/test_embedding_index.py

@@ -0,0 +1,46 @@
+import numpy as np
+import pytest
+from agent_ai.embedding_index import build_faiss_index, search_faiss
+
+def test_build_and_search_faiss_index():
+    embeddings = np.array([
+        [1.0, 0.0, 0.0, 0.0],
+        [0.9, 0.1, 0.0, 0.0],
+        [0.0, 1.0, 0.0, 0.0],
+        [0.0, 0.9, 0.1, 0.0],
+        [0.0, 0.0, 1.0, 0.0]
+    ], dtype=np.float32)
+
+    # Construire l'index
+    index = build_faiss_index(embeddings)
+
+    # Requête : un vecteur proche du premier
+    query = np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float32)
+
+    distances, indices = search_faiss(index, query, top_k=3)
+
+    # Vérifier la forme des résultats
+    assert distances.shape == (1, 3)
+    assert indices.shape == (1, 3)
+
+    # Le vecteur le plus proche doit être lui-même (distance max = 1 après normalisation)
+    assert indices[0, 0] == 0
+    assert np.isclose(distances[0, 0], 0.0, atol=1e-5)
+
+
+    # Les distances doivent être décroissantes (cosine similarity décroissante)
+    assert distances[0, 0] <= distances[0, 1] <= distances[0, 2]
+
+def test_search_batch_queries():
+    embeddings = np.random.rand(10, 8).astype(np.float32)
+    index = build_faiss_index(embeddings)
+
+    queries = np.array([
+        embeddings[0],
+        embeddings[1]
+    ])
+
+    distances, indices = search_faiss(index, queries, top_k=2)
+
+    assert distances.shape == (2, 2)
+    assert indices.shape == (2, 2)

+ 15 - 0
tests/test_qa_chain.py

@@ -0,0 +1,15 @@
+from unittest.mock import patch
+from agent_ai.qa_chain import get_qa_chain
+
+def test_get_qa_chain_mocked():
+    with patch("agent_ai.qa_chain.OllamaLLM.invoke") as mock_invoke:
+        mock_invoke.return_value = {"text": "Paris !"}
+        
+        chain = get_qa_chain()
+
+        output = chain.invoke({
+            "context": "Paris est la capitale de la France.",
+            "question": "Quelle est la capitale de la France ?"
+        })
+
+        assert output["text"] == "Paris."

+ 38 - 0
tests/test_scraping.py

@@ -0,0 +1,38 @@
+from unittest.mock import patch
+from agent_ai.scraping import fetch_all_pages_content
+
+@patch("agent_ai.scraping.session.get")
+def test_fetch_success(mock_get):
+    mock_get.return_value.status_code = 200
+    mock_get.return_value.text = '''
+        <textarea name="wikitext">Sample content</textarea>
+    '''
+
+    urls = ["https://example.com/page"]
+    result = fetch_all_pages_content(urls)
+    assert result[urls[0]] == "Sample content"
+
+@patch("agent_ai.scraping.session.get")
+def test_fetch_no_textarea(mock_get):
+    mock_get.return_value.status_code = 200
+    mock_get.return_value.text = "<html>No textarea</html>"
+
+    urls = ["https://example.com/no-textarea"]
+    result = fetch_all_pages_content(urls)
+    assert urls[0] not in result
+
+@patch("agent_ai.scraping.session.get")
+def test_fetch_error_status(mock_get):
+    mock_get.return_value.status_code = 404
+
+    urls = ["https://example.com/404"]
+    result = fetch_all_pages_content(urls)
+    assert urls[0] not in result
+
+@patch("agent_ai.scraping.session.get")
+def test_fetch_exception(mock_get):
+    mock_get.side_effect = Exception("Network error")
+
+    urls = ["https://example.com/error"]
+    result = fetch_all_pages_content(urls)
+    assert urls[0] not in result