Initial commit: code + hf-space (plain folder), ignore index/venv

.gitignore

@@ -0,0 +1,33 @@
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.egg-info/
+*.eggs/
+build/
+dist/
+
+# venv & OS
+.venv/
+.env/
+.DS_Store
+.tmp-venv/
+
+# Notebooks & cache
+.ipynb_checkpoints/
+.cache/
+
+# Temp
+tmp/
+logs/
+
+# Data / artefacts locaux
+faiss_open_index/
+*.parquet
+*.arrow
+*.faiss
+*.pkl
+
+# HF token local si jamais
+.huggingface/

app.py

@@ -0,0 +1,56 @@
+# app.py — UI Gradio simple (FAISS-only) avec citations cliquables
+import gradio as gr
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+
+INDEX_DIR = "faiss_open_index"
+EMBED_MODEL = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+
+def load_vs():
+    emb = HuggingFaceEmbeddings(
+        model_name=EMBED_MODEL,
+        encode_kwargs={"normalize_embeddings": True},
+    )
+    # L’index doit être présent dans ./faiss_open_index
+    return FAISS.load_local(INDEX_DIR, emb, allow_dangerous_deserialization=True)
+
+vs = load_vs()
+
+def search(query: str, k: int, lang_filter: str):
+    q = (query or "").strip()
+    if not q:
+        return "<i>Entre une question…</i>"
+    docs = vs.similarity_search(q, k=int(k))
+    # petit filtre langue (optionnel)
+    if lang_filter in ("FR", "EN"):
+        keep = "fr" if lang_filter == "FR" else "en"
+        docs = [d for d in docs if (d.metadata.get("language","") == keep)] or docs
+
+    html = []
+    for i, d in enumerate(docs, 1):
+        title = d.metadata.get("title", "—")
+        url   = d.metadata.get("url", "#")
+        lang  = d.metadata.get("language", "—")
+        snippet = (d.page_content[:420] + "…").replace("\n", " ")
+        html.append(
+            f"<div style='margin:10px 0;padding:10px;border:1px solid #eee;border-radius:12px'>"
+            f"<div><b>{i}. {title}</b> <span style='opacity:.6'>[{lang}]</span></div>"
+            f"<div style='margin:4px 0'><a href='{url}' target='_blank'>{url}</a></div>"
+            f"<div style='opacity:.85'>{snippet}</div>"
+            f"</div>"
+        )
+    return "\n".join(html)
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("## 🔎 Experiment Brief — Recherche sourcée (FAISS)")
+    with gr.Row():
+        q = gr.Textbox(label="Ta question", placeholder="Ex. Différence interleaving vs A/B ?")
+    with gr.Row():
+        k = gr.Slider(1, 10, value=5, step=1, label="Nombre de passages (k)")
+        lang = gr.Radio(choices=["Tous", "FR", "EN"], value="Tous", label="Langue")
+    go = gr.Button("Rechercher")
+    out = gr.HTML()
+    go.click(search, inputs=[q, k, lang], outputs=out)
+
+if __name__ == "__main__":
+    demo.launch()

build_open_dataset_curated.py

@@ -0,0 +1,139 @@
+# build_open_dataset_curated.py — Wikipédia FR/EN must-have (strict mais pragmatique)
+from typing import List, Dict, Optional
+import wikipediaapi
+from datasets import Dataset, DatasetDict, Features, Value, Sequence
+
+HF_USER = "lmhdii"
+DS_NAME = f"{HF_USER}/experiment-brief-open"
+
+# ----- Candidats par thème (on essaie dans l'ordre) -----
+CANDIDATES_EN = {
+    "A/B testing": ["A/B testing", "Split testing"],
+    "Interleaving": ["Interleaving (information retrieval)", "Team-draft interleaving"],
+    "Sequential analysis": ["Sequential analysis"],
+    "False discovery rate": ["False discovery rate", "Benjamini–Hochberg procedure", "Benjamini-Hochberg procedure"],
+    "Sample size": ["Sample size determination"],
+    "Power": ["Power (statistics)"],
+    "Non-inferiority": ["Non-inferiority trial"],
+    "Equivalence": ["Equivalence test"],
+    "Bandit": ["Multi-armed bandit"],
+    "Thompson": ["Thompson sampling"],
+    "Randomized": ["Randomized controlled trial", "Randomized experiment"],
+    "Control": ["Scientific control", "Controlled experiment", "Control group"],
+    "EN Interleaving" : ["Team-draft interleaving", "Interleaving (statistics)"],
+}
+
+CANDIDATES_FR = {
+    "Test A/B": ["Test A/B"],
+    "Analyse séquentielle": ["Analyse séquentielle"],
+    "FDR": ["Taux de fausses découvertes", "Taux de fausse découverte"],
+    "Benjamini-Hochberg": ["Procédure de Benjamini-Hochberg", "Procédure de Benjamini–Hochberg"],
+    "Taille d'échantillon": ["Taille d'échantillon", "Échantillon (statistiques)"],
+    "Puissance": ["Puissance statistique", "Puissance (statistique)"],
+    "Non-infériorité": ["Essai de non-infériorité"],
+    "Équivalence": ["Test d'équivalence (statistiques)", "Test d'équivalence"],
+    "Bandit": ["Bandit manchot"],
+    "Thompson": ["Échantillonnage de Thompson"],
+    "Essai randomisé": ["Essai randomisé contrôlé"],
+    "Témoin": ["Groupe témoin"],  # + proche de "Scientific control"
+    "FR FDR" : ["Taux de fausses découvertes", "Taux de fausse découverte (statistiques)"],
+    "FR Non-infériorité" : ["Essai de non-infériorité", "Essai de non-infériorité (statistiques)"],
+    "FR Équivalence" : ["Test d'équivalence (statistiques)", "Test d'équivalence"],
+}
+
+FEATURES = Features({
+    "id":          Value("string"),
+    "source_type": Value("string"),
+    "title":       Value("string"),
+    "url":         Value("string"),
+    "language":    Value("string"),
+    "year":        Value("string"),
+    "topics":      Sequence(Value("string")),
+    "text":        Value("string"),
+})
+
+# --- Garde-fou "pertinence domaine" (un poil plus large) ---
+KEYS_EN = [
+    "a/b testing","split testing","online controlled experiment","interleaving",
+    "information retrieval","sample ratio mismatch","srm","cuped","guardrail",
+    "overall evaluation criterion","oec","sequential","false discovery rate",
+    "benjamini","multi-armed bandit","thompson sampling","non-inferiority",
+    "equivalence test","power (statistics)","sample size","scientific control",
+    "controlled experiment","control group","randomized controlled trial"
+]
+KEYS_FR = [
+    "test a/b","expérience contrôlée","essai randomisé","analyse séquentielle",
+    "taux de fausses découvertes","benjamini","taille d'échantillon",
+    "puissance (statistique)","puissance statistique","non-infériorité",
+    "test d'équivalence","bandit manchot","échantillonnage de thompson",
+    "groupe témoin","essai randomisé contrôlé"
+]
+BLOCK_TITLES = {
+    "Audio Video Interleave","Desirable difficulty","Essais (Montaigne)",
+    "Équivalent métabolique","Expérience de Stanford"
+}
+
+def relevant(title: str, text: str, lang: str) -> bool:
+    if title in BLOCK_TITLES:
+        return False
+    t = (title or "").lower()
+    x = (text or "").lower()
+    keys = KEYS_EN if lang == "en" else KEYS_FR
+    return any(k in t or k in x for k in keys)
+def fetch_best(wiki, lang, candidates):
+    # 1) essai strict + garde-fou
+    for title in candidates:
+        p = wiki.page(title)
+        if p.exists() and (p.text or "").strip() and relevant(p.title, p.text, lang):
+            return {
+                "id": f"wiki::{lang}::{p.title}",
+                "source_type": "wiki",
+                "title": p.title,
+                "url": p.fullurl,
+                "language": lang,
+                "year": "",
+                "topics": [],
+                "text": p.text or "",
+            }
+    # 2) fallback "force include" si la page existe mais le garde-fou est trop strict
+    for title in candidates:
+        p = wiki.page(title)
+        if p.exists() and (p.text or "").strip():
+            return {
+                "id": f"wiki::{lang}::{p.title}",
+                "source_type": "wiki",
+                "title": p.title,
+                "url": p.fullurl,
+                "language": lang,
+                "year": "",
+                "topics": [],
+                "text": p.text or "",
+            }
+    return None
+
+def collect(lang: str, topics: Dict[str,List[str]]) -> List[Dict]:
+    wiki = wikipediaapi.Wikipedia(language=lang, user_agent="experiment-brief-assistant/0.4")
+    out, seen = [], set()
+    for _, cand in topics.items():
+        row = fetch_best(wiki, lang, cand)
+        if row and row["title"] not in seen:
+            out.append(row); seen.add(row["title"])
+            print(f"✓ [{lang}] {row['title']}")
+        else:
+            print(f"⚠️  missing: [{lang}] {cand}")
+    return out
+
+if __name__ == "__main__":
+    print("→ Fetch curated EN (patched)…")
+    en_rows = collect("en", CANDIDATES_EN)
+    print("→ Fetch curated FR (patched)…")
+    fr_rows = collect("fr", CANDIDATES_FR)
+
+    wiki_en = Dataset.from_list(en_rows, features=FEATURES)
+    wiki_fr = Dataset.from_list(fr_rows, features=FEATURES)
+    dsd = DatasetDict({"wiki_en": wiki_en, "wiki_fr": wiki_fr})
+    print({k: len(v) for k, v in dsd.items()})
+
+    print(f"→ Push to Hub: {DS_NAME}")
+    dsd.push_to_hub(DS_NAME, private=False)
+    print("✅ Dataset publié (curated patched).")

hf-space/.gitattributes

@@ -0,0 +1,36 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+faiss_open_index/* filter=lfs diff=lfs merge=lfs -text

hf-space/README.md

@@ -0,0 +1,13 @@
+---
+title: Experiment Checklist Assistant
+emoji: 🏢
+colorFrom: indigo
+colorTo: pink
+sdk: gradio
+sdk_version: 5.49.1
+app_file: app.py
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

hf-space/app.py

@@ -0,0 +1,56 @@
+# app.py — UI Gradio simple (FAISS-only) avec citations cliquables
+import gradio as gr
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+
+INDEX_DIR = "faiss_open_index"
+EMBED_MODEL = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+
+def load_vs():
+    emb = HuggingFaceEmbeddings(
+        model_name=EMBED_MODEL,
+        encode_kwargs={"normalize_embeddings": True},
+    )
+    # L’index doit être présent dans ./faiss_open_index
+    return FAISS.load_local(INDEX_DIR, emb, allow_dangerous_deserialization=True)
+
+vs = load_vs()
+
+def search(query: str, k: int, lang_filter: str):
+    q = (query or "").strip()
+    if not q:
+        return "<i>Entre une question…</i>"
+    docs = vs.similarity_search(q, k=int(k))
+    # petit filtre langue (optionnel)
+    if lang_filter in ("FR", "EN"):
+        keep = "fr" if lang_filter == "FR" else "en"
+        docs = [d for d in docs if (d.metadata.get("language","") == keep)] or docs
+
+    html = []
+    for i, d in enumerate(docs, 1):
+        title = d.metadata.get("title", "—")
+        url   = d.metadata.get("url", "#")
+        lang  = d.metadata.get("language", "—")
+        snippet = (d.page_content[:420] + "…").replace("\n", " ")
+        html.append(
+            f"<div style='margin:10px 0;padding:10px;border:1px solid #eee;border-radius:12px'>"
+            f"<div><b>{i}. {title}</b> <span style='opacity:.6'>[{lang}]</span></div>"
+            f"<div style='margin:4px 0'><a href='{url}' target='_blank'>{url}</a></div>"
+            f"<div style='opacity:.85'>{snippet}</div>"
+            f"</div>"
+        )
+    return "\n".join(html)
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("## 🔎 Experiment Brief — Recherche sourcée (FAISS)")
+    with gr.Row():
+        q = gr.Textbox(label="Ta question", placeholder="Ex. Différence interleaving vs A/B ?")
+    with gr.Row():
+        k = gr.Slider(1, 10, value=5, step=1, label="Nombre de passages (k)")
+        lang = gr.Radio(choices=["Tous", "FR", "EN"], value="Tous", label="Langue")
+    go = gr.Button("Rechercher")
+    out = gr.HTML()
+    go.click(search, inputs=[q, k, lang], outputs=out)
+
+if __name__ == "__main__":
+    demo.launch()

hf-space/requirements.txt

@@ -0,0 +1,6 @@
+numpy<2
+faiss-cpu==1.7.4
+gradio>=4.25,<5
+langchain-community>=0.2,<0.4
+sentence-transformers>=2.2,<3
+huggingface-hub>=0.20

hybrid_search.py

@@ -0,0 +1,156 @@
+# hybrid_search.py — Hybrid retrieval (FAISS dense + BM25 lexical) + query rewrite + domain filter + SRM boost
+# Compatible Python 3.9
+
+from typing import List, Tuple, Dict
+from collections import defaultdict
+import re
+
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.retrievers import BM25Retriever
+from langchain_core.documents import Document
+
+# ---------- Config ----------
+INDEX_DIR = "faiss_open_index"  # dossier créé par index_open_faiss.py
+EMBED_MODEL = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
+
+# Expansion de requêtes (ajoute du contexte domaine)
+EXPAND: Dict[str, List[str]] = {
+    r"\binterleaving\b": [
+        "team-draft interleaving", "search ranking evaluation", "information retrieval"
+    ],
+    r"\ba/?b\b": [
+        "ab testing", "split testing", "online controlled experiment", "randomized experiment"
+    ],
+    r"\bsrm\b|sample ratio mismatch": [
+        "randomization check", "allocation imbalance", "allocation ratio",
+        "chi-squared test", "goodness of fit", "pearson chi-squared", "A/A test"
+    ],
+    r"\bcuped\b": ["variance reduction", "covariate adjustment"],
+    r"\bguardrail(s)?\b": ["guardrail metric", "overall evaluation criterion", "oec"],
+    r"\bsequential\b": ["sequential analysis", "alpha spending", "group sequential"],
+    r"\bfdr\b|\bfalse discovery rate\b": ["benjamini", "benjamini–hochberg"],
+    r"\bbandit\b": ["multi-armed bandit", "thompson sampling"],
+    r"\bnon[- ]?inferiority\b": ["equivalence test"],
+}
+
+# Termes de domaine pour filtrer les résultats trop génériques
+DOMAIN_TERMS = [
+    "a/b testing","ab testing","split testing","online controlled experiment",
+    "interleaving","team-draft interleaving","information retrieval",
+    "sample ratio mismatch","srm","randomization check","allocation ratio",
+    "chi-squared","pearson","goodness of fit","a/a test",
+    "cuped","guardrail","overall evaluation criterion","oec",
+    "sequential analysis","alpha spending","false discovery rate","benjamini",
+    "multi-armed bandit","thompson sampling","non-inferiority","equivalence test",
+    "power analysis","sample size determination","control group","scientific control",
+]
+
+# Légers boosts pour les requêtes SRM
+BOOST_TERMS = [
+    "sample ratio mismatch","randomization check","allocation ratio",
+    "chi-squared","goodness of fit","a/a test"
+]
+
+# ---------- Utilitaires ----------
+def rewrite(q: str) -> str:
+    """Ajoute des termes de domaine en fonction de la requête."""
+    qn = q.lower()
+    extra: List[str] = []
+    for pat, terms in EXPAND.items():
+        if re.search(pat, qn):
+            extra += terms
+    return q if not extra else f"{q} " + " ".join(extra)
+
+def rrf(dense_hits: List[Tuple[Document, float]],
+        sparse_hits: List[Document],
+        k: int = 60,
+        topk: int = 5) -> List[Document]:
+    """Reciprocal Rank Fusion (RRF) — fusionne l'ordre dense et lexical."""
+    score = defaultdict(float)
+
+    for rank, (doc, _) in enumerate(dense_hits, start=1):
+        score[id(doc)] += 1.0 / (k + rank)
+
+    for rank, doc in enumerate(sparse_hits, start=1):
+        score[id(doc)] += 1.0 / (k + rank)
+
+    uniq: Dict[int, Document] = {}
+    for (doc, _) in dense_hits:
+        uniq[id(doc)] = doc
+    for doc in sparse_hits:
+        uniq[id(doc)] = doc
+
+    ranked = sorted(uniq.values(), key=lambda d: score[id(d)], reverse=True)
+    return ranked[:topk]
+
+def is_domain(doc: Document) -> bool:
+    """Filtre simple : conserve les docs contenant des termes de notre domaine."""
+    hay = (doc.metadata.get("title", "") + " " + doc.page_content).lower()
+    return any(t in hay for t in DOMAIN_TERMS)
+
+def boost_rank(docs: List[Document]) -> List[Document]:
+    """Boost très simple pour SRM (compte des occurrences)."""
+    def score(doc: Document) -> int:
+        txt = (doc.page_content + " " + doc.metadata.get("title","")).lower()
+        return sum(txt.count(t) for t in BOOST_TERMS)
+    return sorted(docs, key=score, reverse=True)
+
+# ---------- Chargement index + BM25 ----------
+def load_retrievers():
+    emb = HuggingFaceEmbeddings(
+        model_name=EMBED_MODEL,
+        encode_kwargs={"normalize_embeddings": True},
+    )
+    # FAISS inclut les chunks quand on sauvegarde via save_local
+    vs = FAISS.load_local(INDEX_DIR, emb, allow_dangerous_deserialization=True)
+
+    # Construire BM25 sur les mêmes documents (chunks)
+    docs = list(vs.docstore._dict.values())
+    bm25 = BM25Retriever.from_documents(docs)
+    bm25.k = 12  # top lexical
+
+    return vs, bm25
+
+# ---------- API de recherche ----------
+class HybridSearcher:
+    def __init__(self):
+        self.vs, self.bm25 = load_retrievers()
+
+    def search(self, q: str, k_dense: int = 12, k_final: int = 5):
+        q2 = rewrite(q)
+
+        # denses + scores
+        dense = self.vs.similarity_search_with_score(q2, k=k_dense)
+
+        # lexical — utiliser .invoke() (évite le warning deprecation)
+        sparse = self.bm25.invoke(q2)
+
+        fused = rrf(dense, sparse, topk=max(k_final * 3, 12))
+        filtered = [d for d in fused if is_domain(d)]
+        candidates = filtered or fused
+        results = boost_rank(candidates)[:k_final]
+        return results, q2
+
+# ---------- CLI ----------
+if __name__ == "__main__":
+    try:
+        hs = HybridSearcher()
+        print("Hybrid search prêt ✅ (FAISS + BM25).")
+        while True:
+            q = input("\nTa question (ENTER pour quitter): ").strip()
+            if not q:
+                break
+            hits, q2 = hs.search(q)
+            print(f"\nQuery réécrite: {q2}")
+            if not hits:
+                print("Aucun résultat.")
+                continue
+            for i, d in enumerate(hits, 1):
+                title = d.metadata.get("title")
+                url = d.metadata.get("url")
+                lang = d.metadata.get("language")
+                snippet = d.page_content[:160].replace("\n", " ")
+                print(f"{i}. {title} [{lang}] — {url}\n   {snippet} …")
+    except KeyboardInterrupt:
+        pass

index_open_faiss.py

@@ -0,0 +1,64 @@
+# index_open_faiss.py — construit un index FAISS à partir du dataset open
+from datasets import load_dataset, DatasetDict
+from langchain_community.embeddings import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from langchain_core.documents import Document
+from tqdm import tqdm
+import re
+
+DATASET_ID = "lmhdii/experiment-brief-open"  # ← laisse ton ID
+INDEX_DIR = "faiss_open_index"
+
+def chunk(text, size=900, overlap=150):
+    text = re.sub(r"\s+", " ", text or "").strip()
+    out, i = [], 0
+    while i < len(text):
+        out.append(text[i:i+size])
+        i += max(size - overlap, 1)
+    return out
+
+print("→ Loading dataset…")
+dsd = DatasetDict()
+for split in ["wiki_en", "wiki_fr"]:
+    try:
+        dsd[split] = load_dataset(DATASET_ID, split=split)
+        print(f"  {split}: {len(dsd[split])} rows")
+    except Exception as e:
+        print(f"  skip {split} ({e})")
+
+docs = []
+for split, ds in dsd.items():
+    for r in tqdm(ds, desc=f"chunk {split}"):
+        meta = {
+            "id": r["id"],
+            "title": r["title"],
+            "url": r["url"],
+            "language": r["language"],
+            "source_type": r["source_type"],
+            "split": split,
+        }
+        for c in chunk(r["text"]):
+            docs.append(Document(page_content=c, metadata=meta))
+
+print(f"→ Total chunks: {len(docs)}")
+
+# Multilingue FR/EN
+emb = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
+    encode_kwargs={"normalize_embeddings": True}
+)
+
+print("→ Building FAISS…")
+vs = FAISS.from_documents(docs, emb)
+vs.save_local(INDEX_DIR)
+print(f"✅ Saved index to ./{INDEX_DIR}")
+
+# Smoke test
+q = "Qu'est-ce qu'un SRM en A/B testing et comment le diagnostiquer ?"
+retriever = vs.as_retriever(search_kwargs={"k": 5})
+hits = retriever.invoke(q)
+
+print("\nTop-5 résultats :")
+for i, d in enumerate(hits, 1):
+    print(f"{i}. {d.metadata.get('title')} [{d.metadata.get('language')}] — {d.metadata.get('url')}")
+    print("   ", d.page_content[:140].replace("\n", " "), "…")

requirements.txt

@@ -0,0 +1,6 @@
+numpy<2
+faiss-cpu==1.7.4
+gradio>=4.25,<5
+langchain-community>=0.2,<0.4
+sentence-transformers>=2.2,<3
+huggingface-hub>=0.20

test_retrieval.py

@@ -0,0 +1,25 @@
+from langchain_community.vectorstores import FAISS
+from langchain_community.embeddings import HuggingFaceEmbeddings
+
+INDEX_DIR = "faiss_open_index"
+
+emb = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2",
+    encode_kwargs={"normalize_embeddings": True}
+)
+
+# allow_dangerous_deserialization est nécessaire pour recharger FAISS sauvegardé
+vs = FAISS.load_local(INDEX_DIR, emb, allow_dangerous_deserialization=True)
+retriever = vs.as_retriever(search_kwargs={"k": 5})
+
+while True:
+    try:
+        q = input("\nTa question (ENTER pour quitter): ").strip()
+        if not q:
+            break
+        hits = retriever.invoke(q)
+        for i, d in enumerate(hits, 1):
+            print(f"{i}. {d.metadata.get('title')} — {d.metadata.get('url')}")
+            print("   ", d.page_content[:140].replace('\\n',' '), "…")
+    except KeyboardInterrupt:
+        break