OH PUTAIN YES! 🔥 Allez, je te fais un prompt de MALADE pour la section Embeddings + la Synthèse finale! Let's finish strong! (ง'̀-'́)ง

---

📋 PROMPT POUR CURSOR AGENT - EMBEDDINGS & SYNTHÈSE

# MISSION: Ajouter les Sections Embeddings et Synthèse Comparative

## 🎯 CONTEXTE

Les sections TF-IDF et BM25 sont complètes et fonctionnent bien. Maintenant, tu dois:

1. **Implémenter la section Embeddings** (la plus avancée)
2. **Créer la section Synthèse Comparative** (comparaison des 3 techniques)
3. **Finaliser l'application** avec une page d'accueil complète

**Public cible:** Étudiants francophones en développement web (niveau bac+2/3)

**Objectif:** Montrer la puissance des embeddings vectoriels et guider les étudiants dans le choix de la bonne technique selon leur cas d'usage.

---

## 🏗️ ARCHITECTURE FINALE DE L'APPLICATION

### Structure complète:

🔍 EXPLORATEUR DE RECHERCHE TEXTUELLE

├── 🏠 Accueil │ ├── Présentation générale │ ├── Navigation guidée │ └── Quick Start │ ├── 📊 1. TF-IDF (✅ FAIT) ├── 🎯 2. BM25 (✅ FAIT) │ ├── 🧠 3. Embeddings Vectoriels (← À CRÉER) │ ├── 📖 Introduction & Limites Lexicales │ ├── 🔢 Concepts des Embeddings │ ├── 🔍 Recherche Interactive │ ├── 📊 Exploration & Visualisations │ ├── 🎓 Exemple Pas-à-Pas │ ├── ⚔️ Comparaison avec BM25/TF-IDF │ ├── 🎨 Hybrid Search (BM25 + Embeddings) │ └── ⚡ Performance │ └── 📊 4. Synthèse Comparative (← À CRÉER) ├── 📋 Tableau Comparatif ├── 🎯 Guide de Décision ├── 💼 Cas d'Usage Réels ├── 🔬 Benchmark Comparatif └── 🚀 Recommandations Finales

---

## 📚 CONTENU PÉDAGOGIQUE - EMBEDDINGS

### 📖 Sous-section 1: Introduction & Limites Lexicales

**Structure:**

#### **1.1 Rappel TF-IDF/BM25**

Encadré récapitulatif:
```python
st.info("""
📊 **Ce que vous avez appris:**

- **TF-IDF:** Recherche par fréquence des mots
- **BM25:** TF-IDF amélioré avec saturation

**Principe commun:** Recherche LEXICALE (mots exacts)
""")

1.2 Les 4 Fails Critiques des Approches Lexicales

Fail #1: Synonymes

Exemple interactif avec deux colonnes:

col1, col2 = st.columns(2)

with col1:
    st.markdown("**Query:**")
    st.code("voiture rapide")

with col2:
    st.markdown("**Document:**")
    st.code("automobile véloce")

st.error("❌ TF-IDF/BM25 Score: 0.0 (aucun mot commun)")
st.success("✅ Embeddings Score: 0.94 (sens identique!)")

Visualisation:

# Graphique montrant le matching lexical vs sémantique
# Diagramme de Venn ou similaire

Fail #2: Polysémie

Exemple avec "Apple":

st.markdown("""
### 🍎 Problème de la Polysémie

**Mot:** "Apple"

**Contexte 1:** "Apple fait de bons ordinateurs" → Entreprise tech 💻
**Contexte 2:** "Apple est un fruit délicieux" → Fruit 🍎

**TF-IDF/BM25:** Les deux matchent pareil (mot identique)
**Embeddings:** Distingue les deux sens selon le contexte! ✅
""")

Fail #3: Relations Conceptuelles

Exemple "Paris capitale France":

# Tableau comparatif
data = {
    'Document': [
        'Paris est une belle ville',
        'La France est un grand pays'
    ],
    'TF-IDF': [0.0, 0.45],
    'Embeddings': [0.88, 0.31]
}

st.table(pd.DataFrame(data))

st.markdown("""
**Pourquoi?**
- TF-IDF match "France" dans Doc 2 ✅
- Embeddings comprend que "Paris" est lié à "capitale France" 🤯
""")

Fail #4: Paraphrases

Exemple frappant:

phrase_a = "Le chat poursuit la souris"
phrase_b = "Le félin traque le rongeur"

st.markdown(f"""
**Phrase A:** {phrase_a}
**Phrase B:** {phrase_b}

**Sens:** IDENTIQUE ✅
**Mots communs:** 2/6 ("le" ×2)

- TF-IDF Similarity: ~0.15
- Embeddings Similarity: ~0.91 🔥
""")

1.3 La Solution: Embeddings Vectoriels

Grande encadré avec animation ou graphique:

st.success("""
🧠 **Les Embeddings: La Révolution Sémantique**

Au lieu de compter des mots, on capture le SENS dans un espace vectoriel dense.

**Principe:**
Texte → Neural Network → Vecteur de nombres → Comparaison géométrique

**Résultat:**
"voiture" et "automobile" deviennent des vecteurs PROCHES dans l'espace!
""")

Visualisation conceptuelle:

# Schéma simplifié du pipeline
# Texte → [Tokenizer] → [BERT/Transformer] → [Pooling] → Vector (384 dim)

---

🔢 Sous-section 2: Concepts des Embeddings

Structure avec expanders:

2.1 Sparse vs Dense

Tableau comparatif visuel:

col1, col2 = st.columns(2)

with col1:
    st.markdown("### 📊 TF-IDF (Sparse)")
    st.code("""
Vocabulaire: 10,000 mots
Doc: "Le chat mange"

Vector: [0, 0, 0, ..., 0.5, 0, ..., 0.8, ...]
        └──────────┬──────────┘
           99.97% de zéros!

Dimensions: 10,000
Non-zéros: ~3 (0.03%)
    """)

with col2:
    st.markdown("### 🧠 Embeddings (Dense)")
    st.code("""
Doc: "Le chat mange"

Vector: [0.234, -0.891, 0.456, ..., -0.123]
        └────────────┬────────────┘
        Toutes valeurs non-nulles!

Dimensions: 384
Non-zéros: 384 (100%)
    """)

st.markdown("""
**Avantage Dense:**
- Chaque dimension capture un "concept" sémantique
- Pas de dimensions gaspillées
- Représentation beaucoup plus riche! ✨
""")

2.2 Le Pipeline: De Texte à Vecteur

Schéma détaillé avec étapes:

# Utiliser st.graphviz ou créer un flowchart avec plotly
st.markdown("""
### 🔄 Pipeline de Transformation

```text
1. Texte Brut
   "Le chat mange du poisson"

2. Tokenization
   ["le", "chat", "mange", "du", "poisson"]

3. Neural Network (Transformer)
   - Embedding Layer: mots → vecteurs initiaux
   - Attention Layers (×12): capture le contexte
   - Pooling: agrégation en un seul vecteur

4. Vecteur Final
   [0.234, -0.891, 0.456, ..., -0.123]  (384 dimensions)

""")

**Explication du Transformer:**

```python
with st.expander("🤔 Qu'est-ce qu'un Transformer?"):
    st.markdown("""
    ### Architecture BERT/Sentence-BERT

    **Attention Mechanism (le cœur):**

    Imagine la phrase: "La banque est fermée"

    **Question:** "banque" = institution financière ou bord de rivière?

    **L'Attention regarde le contexte:**
    - Mot "fermée" → Institution financière (probable) ✅
    - Si c'était "La banque du fleuve" → Bord de rivière

    **Mécanisme:**
    Chaque mot "regarde" les autres mots pour comprendre son sens.

    ```
    Phrase: "Le chat noir mange"

    Attention de "noir":
    - Vers "chat": 0.8 ← Fort! (noir décrit chat)
    - Vers "mange": 0.1 ← Faible
    - Vers "le": 0.1
    ```

    **Après 12 couches d'attention:**
    Le réseau a une compréhension profonde du sens! 🧠
    """)

    # Visualisation des attention weights (si possible)

2.3 L'Entraînement: Comment le Réseau Apprend

st.markdown("""
### 📚 Masked Language Modeling

**Tâche d'entraînement:**

```python
# Phrase originale
"Le chat mange du poisson"

# Phrase maskée
"Le [MASK] mange du poisson"

# Objectif
Prédire que [MASK] = "chat"

Pourquoi ça marche?

Pour prédire correctement, le réseau DOIT comprendre:

• "mange" → sujet vivant (pas "table")
• "du poisson" → prédateur (pas "vache")
• Contexte français → vocabulaire adapté

Après des milliards d'exemples: Le réseau apprend des représentations sémantiques riches! ✨ """)

Animation ou schéma du processus d'entraînement

#### **2.4 Les Dimensions: Que Représentent-elles?**

```python
st.markdown("""
### 🌈 L'Espace Vectoriel

**Exemple conceptuel (simplifié):**

Dimension 0: "vivant vs non-vivant" chat → +0.9 | table → -0.7

Dimension 1: "concret vs abstrait" pomme → +0.8 | amour → -0.6

Dimension 2: "positif vs négatif (sentiment)" heureux → +0.9 | triste → -0.8

Dimension 3: "animal vs objet" chien → +0.85 | voiture → -0.75 ... Dimension 383: "???" (combinaison complexe)

**En réalité:**
Les 384 dimensions sont des **combinaisons complexes** de milliers de concepts.
Impossible à interpréter directement, mais les relations émergent naturellement! 🪄
""")

# Visualisation PCA/t-SNE montrant les clusters

Visualisation Interactive:

# Widget pour explorer l'espace vectoriel
st.subheader("🎨 Visualisation 2D de l'Espace Vectoriel")

# Exemple avec mots prédéfinis
example_words = [
    "chat", "chien", "hamster",  # Animaux
    "voiture", "camion", "vélo",  # Véhicules
    "heureux", "joyeux", "content",  # Émotions
    "table", "chaise", "lit"  # Meubles
]

# Option de personnalisation
custom_words = st.text_input(
    "Ou entrez vos propres mots (séparés par des virgules):",
    placeholder="amour, haine, guerre, paix"
)

if custom_words:
    words = [w.strip() for w in custom_words.split(",")]
else:
    words = example_words

# Encoder et visualiser
embeddings = model.encode(words)

# PCA ou t-SNE
# Plotly scatter avec labels
# Colorier par catégorie si possible

---

🔍 Sous-section 3: Recherche Interactive

Interface:

st.title("🔍 Recherche Sémantique")

# Query input
query = st.text_input(
    "Votre recherche:",
    placeholder="animal domestique",
    help="Essayez des synonymes, des paraphrases, des concepts!"
)

# Paramètres
with st.expander("⚙️ Paramètres Avancés"):
    col1, col2 = st.columns(2)

    with col1:
        model_name = st.selectbox(
            "Modèle d'embeddings:",
            [
                "paraphrase-multilingual-MiniLM-L12-v2",  # 384 dim, rapide
                "paraphrase-multilingual-mpnet-base-v2",  # 768 dim, meilleur
                "distiluse-base-multilingual-cased-v2"    # 512 dim, équilibré
            ],
            help="Plus de dimensions = meilleur mais plus lent"
        )

    with col2:
        top_k = st.slider("Nombre de résultats:", 1, 20, 5)

# Comparaison multi-techniques
compare_options = st.multiselect(
    "Comparer avec:",
    ["BM25", "TF-IDF", "Hybrid (BM25+Embeddings)"],
    default=[]
)

if st.button("🚀 Rechercher", type="primary"):
    with st.spinner("Recherche en cours..."):
        # Calcul des résultats
        results_embeddings = embedding_search.search(query, top_k)

        # Si comparaisons demandées
        if "BM25" in compare_options:
            results_bm25 = bm25_search.search(query, top_k)

        # ... etc

    # Affichage
    st.success(f"✅ {len(results_embeddings)} résultats trouvés")

    # Layout selon comparaisons
    if compare_options:
        # Multi-colonnes pour comparaisons
        cols = st.columns(len(compare_options) + 1)

        with cols[0]:
            st.markdown("### 🧠 Embeddings")
            for r in results_embeddings:
                # Afficher résultat
                pass

        # ... autres colonnes
    else:
        # Simple colonne
        for i, result in enumerate(results_embeddings, 1):
            with st.container():
                st.markdown(f"### {i}. [Score: {result['score']:.3f}]")

                # Badge catégorie si disponible
                if 'category' in result:
                    st.badge(result['category'])

                # Titre/Snippet
                st.markdown(f"**{result['title']}**")
                st.caption(result['text'][:200] + "...")

                # Bouton pour explication
                with st.expander("📊 Voir les détails"):
                    st.json(result)  # ou affichage plus structuré

Features importantes:

1. Highlight des concepts matchés (pas des mots exacts!)
2. Score de confiance avec interprétation
3. Suggestions de recherches similaires
4. Export des résultats

---

📊 Sous-section 4: Exploration & Visualisations

Contenu:

4.1 Visualisation 3D Interactive

st.subheader("🌌 Espace Vectoriel 3D")

# Options de visualisation
viz_docs = st.multiselect(
    "Sélectionner des documents à visualiser:",
    options=range(len(corpus)),
    format_func=lambda i: f"Doc {i}: {corpus[i][:50]}...",
    default=list(range(min(20, len(corpus))))
)

# Ajouter query
include_query = st.checkbox("Inclure la query dans la visualisation", value=True)

# Réduction dimensionnelle
reduction_method = st.radio(
    "Méthode de réduction:",
    ["PCA (rapide)", "t-SNE (meilleur clustering)", "UMAP (compromis)"],
    horizontal=True
)

if st.button("Générer la visualisation 3D"):
    # Code de réduction + plot Plotly 3D interactif
    # Lignes reliant query aux top 3 résultats
    # Couleurs par catégorie si disponible
    pass

Visualisation attendue:

• Scatter 3D rotatif (Plotly)
• Query en rouge (star/diamond)
• Documents en bleu
• Lignes vertes vers top résultats
• Hover showing text snippet

4.2 Heatmap de Similarité

st.subheader("🔥 Matrice de Similarité")

# Option de filtrage
num_docs_viz = st.slider(
    "Nombre de documents à afficher:",
    5, 50, 20
)

# Calculer matrice de similarité
similarity_matrix = cosine_similarity(embeddings[:num_docs_viz])

# Heatmap avec seaborn/plotly
fig, ax = plt.subplots(figsize=(12, 10))
sns.heatmap(
    similarity_matrix,
    annot=False,  # Trop de valeurs
    cmap='RdYlGn',
    vmin=0,
    vmax=1,
    square=True,
    cbar_kws={'label': 'Similarité Cosinus'},
    xticklabels=[f"Doc {i}" for i in range(num_docs_viz)],
    yticklabels=[f"Doc {i}" for i in range(num_docs_viz)]
)
plt.title('Matrice de Similarité Sémantique')
st.pyplot(fig)

# Insights automatiques
st.markdown("""
**📊 Observations:**
- Les documents similaires apparaissent en vert/jaune
- Les blocs de couleur révèlent des clusters thématiques
- Diagonale = 1.0 (document identique à lui-même)
""")

4.3 Clustering Automatique

st.subheader("🎯 Clusters Thématiques")

# Nombre de clusters
n_clusters = st.slider("Nombre de clusters:", 2, 10, 3)

# K-means clustering
from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters=n_clusters, random_state=42)
clusters = kmeans.fit_predict(embeddings)

# Visualisation 2D (t-SNE)
from sklearn.manifold import TSNE

tsne = TSNE(n_components=2, random_state=42)
embeddings_2d = tsne.fit_transform(embeddings)

# Plot
fig, ax = plt.subplots(figsize=(14, 10))
scatter = ax.scatter(
    embeddings_2d[:, 0],
    embeddings_2d[:, 1],
    c=clusters,
    cmap='tab10',
    s=100,
    alpha=0.6
)

# Annotations pour quelques docs
for i in range(0, len(corpus), max(1, len(corpus)//20)):
    ax.annotate(
        f"Doc {i}",
        (embeddings_2d[i, 0], embeddings_2d[i, 1]),
        fontsize=8
    )

plt.colorbar(scatter, label='Cluster')
plt.title('Clustering Automatique des Documents')
st.pyplot(fig)

# Afficher quelques docs par cluster
st.markdown("### 📑 Documents par Cluster")

for cluster_id in range(n_clusters):
    with st.expander(f"Cluster {cluster_id} ({sum(clusters == cluster_id)} documents)"):
        cluster_docs = [i for i, c in enumerate(clusters) if c == cluster_id]
        for doc_id in cluster_docs[:5]:  # Afficher 5 premiers
            st.write(f"- Doc {doc_id}: {corpus[doc_id][:100]}...")

4.4 Documents Similaires

st.subheader("🔗 Explorer les Similarités")

# Sélection d'un document
selected_doc_id = st.selectbox(
    "Choisir un document:",
    options=range(len(corpus)),
    format_func=lambda i: f"Doc {i}: {corpus[i][:60]}..."
)

# Trouver les plus similaires
doc_embedding = embeddings[selected_doc_id]
similarities = cosine_similarity([doc_embedding], embeddings)[0]
similarities[selected_doc_id] = -1  # Exclure le doc lui-même

# Top 5
top_indices = np.argsort(similarities)[-5:][::-1]

st.markdown(f"**Document source:**")
st.info(corpus[selected_doc_id])

st.markdown("**Documents similaires:**")

for i, idx in enumerate(top_indices, 1):
    with st.container():
        col1, col2 = st.columns([1, 4])
        with col1:
            st.metric(f"#{i}", f"{similarities[idx]:.3f}")
        with col2:
            st.write(corpus[idx])

---

🎓 Sous-section 5: Exemple Pas-à-Pas

Format détaillé:

st.title("🎓 Exemple Complet: De A à Z")

st.markdown("""
On va dérouler TOUT le processus sur un exemple simple.
Vous allez voir exactement ce qui se passe "sous le capot". 🔍
""")

# Setup
corpus_example = [
    "Le chat noir dort paisiblement",
    "Un chien joue avec une balle",
    "La voiture roule vite"
]
query_example = "animal domestique"

st.markdown("### 📝 Setup")
st.code(f"""
Corpus:
{chr(10).join(f'  Doc {i}: "{doc}"' for i, doc in enumerate(corpus_example))}

Query: "{query_example}"
""")

# Étape 1: Tokenization
st.markdown("### 1️⃣ Tokenization")

with st.expander("Voir les détails"):
    st.markdown("""
    Le texte est découpé en tokens (mots ou sous-mots).

    **Exemple avec sub-word tokenization:**
    """)

    # Pseudo-code
    st.code("""
Query: "animal domestique"
Tokens: ["animal", "domestique"]

Doc 0: "Le chat noir dort paisiblement"
Tokens: ["le", "chat", "noir", "dort", "paisible", "##ment"]
    """)

# Étape 2: Neural Network
st.markdown("### 2️⃣ Passage dans le Réseau de Neurones")

st.markdown("""
Chaque document passe à travers un Transformer (BERT).

**Architecture simplifiée:**
""")

# Schéma ou flowchart
st.code("""
Input Tokens
    ↓
Embedding Layer (tokens → vecteurs 384D)
    ↓
Attention Layer 1 (contexte local)
Attention Layer 2
...
Attention Layer 12 (contexte global)
    ↓
Pooling (moyenne des tokens)
    ↓
Output: Dense Vector (384 dimensions)
""")

st.info("⏱️ Sur un GPU: ~10ms par document. Sur CPU: ~100ms")

# Étape 3: Vecteurs Résultants
st.markdown("### 3️⃣ Vecteurs Générés")

# Afficher les vrais embeddings (tronqués)
embeddings_example = model.encode([query_example] + corpus_example)

for i, text in enumerate([query_example] + corpus_example):
    label = "Query" if i == 0 else f"Doc {i-1}"

    with st.expander(f"{label}: {text}"):
        vec = embeddings_example[i]
        st.code(f"""
Vector (384 dimensions):
[{vec[0]:.3f}, {vec[1]:.3f}, {vec[2]:.3f}, ..., {vec[-1]:.3f}]

Premiers 10 éléments:
{vec[:10]}
        """)

# Étape 4: Calcul Similarité
st.markdown("### 4️⃣ Calcul de Similarité Cosinus")

query_vec = embeddings_example[0]
doc_vecs = embeddings_example[1:]

st.markdown("**Formule:**")
st.latex(r"\text{sim}(q, d) = \frac{q \cdot d}{||q|| \times ||d||}")

# Calcul détaillé pour Doc 0
st.markdown("**Exemple détaillé pour Doc 0:**")

with st.expander("Calculs étape par étape"):
    dot_product = np.dot(query_vec, doc_vecs[0])
    norm_q = np.linalg.norm(query_vec)
    norm_d = np.linalg.norm(doc_vecs[0])
    similarity = dot_product / (norm_q * norm_d)

    st.code(f"""
1. Produit scalaire (dot product):
   q · d = {dot_product:.6f}

2. Norme de la query:
   ||q|| = √({norm_q**2:.6f}) = {norm_q:.6f}

3. Norme du document:
   ||d|| = √({norm_d**2:.6f}) = {norm_d:.6f}

4. Similarité cosinus:
   sim = {dot_product:.6f} / ({norm_q:.6f} × {norm_d:.6f})
       = {dot_product:.6f} / {norm_q * norm_d:.6f}
       = {similarity:.6f}
    """)

# Étape 5: Résultats
st.markdown("### 5️⃣ Résultats Finaux")

# Calculer toutes les similarités
similarities = cosine_similarity([query_vec], doc_vecs)[0]

results_df = pd.DataFrame({
    'Document': corpus_example,
    'Score': similarities,
    'Rang': range(1, 4)
})
results_df = results_df.sort_values('Score', ascending=False).reset_index(drop=True)
results_df['Rang'] = range(1, 4)

st.dataframe(results_df, use_container_width=True)

# Interprétation
st.success(f"""
✅ **Résultat:**

Le document "{results_df.iloc[0]['Document']}" est le plus similaire!

**Pourquoi?**
- Embeddings capte que "chat" et "chien" sont des "animaux domestiques"
- Même sans mots exacts en commun! 🎯
""")

---

⚔️ Sous-section 6: Comparaison Multi-Techniques

Scénarios de comparaison:

Scénario 1: Synonymes

st.subheader("🔄 Test: Synonymes")

test_query = "voiture rapide"
test_docs = [
    "automobile véloce",
    "voiture voiture rapide rapide",
    "un chat dort"
]

# Tableau comparatif
comparison_data = []

for doc in test_docs:
    # TF-IDF
    tfidf_score = compute_tfidf_similarity(test_query, doc)

    # BM25
    bm25_score = compute_bm25_similarity(test_query, doc)

    # Embeddings
    emb_score = compute_embedding_similarity(test_query, doc)

    comparison_data.append({
        'Document': doc,
        'TF-IDF': f"{tfidf_score:.3f}",
        'BM25': f"{bm25_score:.3f}",
        'Embeddings': f"{emb_score:.3f}"
    })

df = pd.DataFrame(comparison_data)

# Highlight du meilleur
st.dataframe(
    df.style.highlight_max(axis=0, subset=['TF-IDF', 'BM25', 'Embeddings']),
    use_container_width=True
)

st.markdown("""
**💡 Observation:**

- **TF-IDF/BM25:** Favorise la répétition ("voiture voiture")
- **Embeddings:** Comprend les synonymes ("automobile véloce") ✅
""")

Scénario 2: Cas Réel sur Dataset

st.subheader("⚔️ Battle Royale: Recherche Réelle")

# Input query
battle_query = st.text_input("Query de test:", value="cuisine italienne")

if battle_query:
    # Lancer les 3 techniques
    with st.spinner("Calcul en cours..."):
        results_tfidf = tfidf_engine.search(battle_query, top_k=10)
        results_bm25 = bm25_engine.search(battle_query, top_k=10)
        results_embeddings = embedding_engine.search(battle_query, top_k=10)

    # Affichage comparatif
    col1, col2, col3 = st.columns(3)

    with col1:
        st.markdown("### 📊 TF-IDF")
        for i, (idx, score) in enumerate(results_tfidf[:5], 1):
            st.write(f"{i}. [{score:.2f}] Doc {idx}")

    with col2:
        st.markdown("### 🎯 BM25")
        for i, (idx, score) in enumerate(results_bm25[:5], 1):
            st.write(f"{i}. [{score:.2f}] Doc {idx}")

    with col3:
        st.markdown("### 🧠 Embeddings")
        for i, result in enumerate(results_embeddings[:5], 1):
            st.write(f"{i}. [{result['score']:.2f}] Doc {result['index']}")

    # Métriques de comparaison
    st.markdown("### 📈 Métriques")

    # Overlap des top 10
    set_tfidf = set([idx for idx, _ in results_tfidf])
    set_bm25 = set([idx for idx, _ in results_bm25])
    set_emb = set([r['index'] for r in results_embeddings])

    overlap_all = len(set_tfidf & set_bm25 & set_emb)

    col1, col2, col3 = st.columns(3)

    with col1:
        overlap_tb = len(set_tfidf & set_bm25)
        st.metric("TF-IDF ∩ BM25", f"{overlap_tb}/10")

    with col2:
        overlap_te = len(set_tfidf & set_emb)
        st.metric("TF-IDF ∩ Embeddings", f"{overlap_te}/10")

    with col3:
        overlap_be = len(set_bm25 & set_emb)
        st.metric("BM25 ∩ Embeddings", f"{overlap_be}/10")

    st.info(f"Documents en commun (top 10 des 3): {overlap_all}")

---

🎨 Sous-section 7: Hybrid Search

La combinaison ultime:

st.title("🎨 Hybrid Search: BM25 + Embeddings")

st.markdown("""
### 🤝 Le Meilleur des Deux Mondes

**Principe:**
Combiner les scores de BM25 (lexical) et Embeddings (sémantique).

**Formule:**
```python
score_final = α × score_bm25 + (1-α) × score_embeddings

Où α contrôle le poids de chaque technique. """)

Widget de tuning

alpha = st.slider( "α (poids BM25):", min_value=0.0, max_value=1.0, value=0.5, step=0.05, help="0 = Embeddings pur | 1 = BM25 pur | 0.5 = équilibré" )

st.markdown(f""" Configuration actuelle:

• Poids BM25: {alpha:.0%}
• Poids Embeddings: {(1-alpha):.0%} """)

Query

hybrid_query = st.text_input("Recherche hybrid:", placeholder="smartphone dernière génération")

if hybrid_query: # Calcul hybrid results_hybrid = hybrid_search.search( hybrid_query, top_k=10, alpha=alpha )

# Affichage
st.markdown("### 🏆 Résultats Hybrid")

for i, result in enumerate(results_hybrid, 1):
    with st.container():
        col1, col2, col3, col4 = st.columns([1, 2, 2, 5])

        with col1:
            st.metric(f"#{i}", f"{result['combined_score']:.2f}")

        with col2:
            st.caption("BM25")
            st.write(f"{result['bm25_score']:.2f}")

        with col3:
            st.caption("Embeddings")
            st.write(f"{result['emb_score']:.2f}")

        with col4:
            st.write(result['document'][:100] + "...")

Visualisation de l'effet de alpha

st.markdown("### 📊 Impact du Paramètre α")

Calculer scores pour différents alpha

alpha_values = np.linspace(0, 1, 21) doc_scores = []

sample_doc_idx = 0 # Un doc d'exemple

for a in alpha_values: # Recalculer score pour ce alpha score = hybrid_search.compute_score(hybrid_query, sample_doc_idx, alpha=a) doc_scores.append(score)

Plot

fig, ax = plt.subplots(figsize=(12, 6)) ax.plot(alpha_values, doc_scores, linewidth=3, marker='o') ax.axvline(alpha, color='red', linestyle='--', label=f'α actuel = {alpha}') ax.set_xlabel('α (poids BM25)', fontsize=12) ax.set_ylabel('Score Final', fontsize=12) ax.set_title(f'Évolution du Score selon α\nDocument: {corpus[sample_doc_idx][:50]}...', fontsize=14) ax.grid(True, alpha=0.3) ax.legend() st.pyplot(fig)

Recommandations

st.info(""" 💡 Quand ajuster α?

• α ≈ 0.3-0.4: Corpus avec beaucoup de synonymes, recherche conceptuelle
• α ≈ 0.5-0.6: Équilibré (recommandé par défaut)
• α ≈ 0.7-0.8: Noms exacts importants, codes, IDs """)

---

### ⚡ Sous-section 8: Performance

**Contenu:**

#### **8.1 Complexité et Coûts**

```python
st.subheader("⏱️ Temps de Calcul")

# Tableau comparatif
perf_data = {
    'Opération': [
        'Indexation (1000 docs)',
        'Recherche (1 query)',
        'Recherche (100 queries)',
        'Mémoire (1000 docs)'
    ],
    'TF-IDF': ['~0.1s', '~5ms', '~0.5s', '~2 MB'],
    'BM25': ['~0.1s', '~5ms', '~0.5s', '~2 MB'],
    'Embeddings': ['~30s (GPU) / ~300s (CPU)', '~10ms', '~1s', '~15 MB']
}

st.table(pd.DataFrame(perf_data))

st.warning("""
⚠️ **Embeddings plus lents:**
- Indexation: 10-100× plus lente (nécessite GPU)
- Recherche: 2-3× plus lente
- Mémoire: 5-10× plus gourmande

**Mais:** Qualité de recherche BEAUCOUP meilleure! 🎯
""")

8.2 Benchmark Réel

st.subheader("🏁 Benchmark sur Corpus Réel")

# Options
benchmark_size = st.select_slider(
    "Taille du corpus:",
    options=[100, 500, 1000, 5000, 10000],
    value=1000
)

if st.button("Lancer le benchmark"):
    with st.spinner("Benchmarking en cours..."):
        # Charger corpus
        corpus = load_dataset('wikipedia', sample_size=benchmark_size)

        # Mesurer indexation
        times_index = {}

        # TF-IDF
        start = time.time()
        tfidf = TFIDFEngine(corpus)
        times_index['TF-IDF'] = time.time() - start

        # BM25
        start = time.time()
        bm25 = BM25Engine(corpus)
        times_index['BM25'] = time.time() - start

        # Embeddings
        start = time.time()
        embeddings_engine = EmbeddingSearch()
        embeddings_engine.index(corpus)
        times_index['Embeddings'] = time.time() - start

        # Mesurer recherche
        test_queries = ["histoire france", "technologie moderne", "cuisine italienne"]
        times_search = {k: [] for k in ['TF-IDF', 'BM25', 'Embeddings']}

        for query in test_queries:
            # TF-IDF
            start = time.time()
            tfidf.search(query)
            times_search['TF-IDF'].append(time.time() - start)

            # BM25
            start = time.time()
            bm25.search(query)
            times_search['BM25'].append(time.time() - start)

            # Embeddings
            start = time.time()
            embeddings_engine.search(query)
            times_search['Embeddings'].append(time.time() - start)

        # Résultats
        st.markdown("### 📊 Résultats")

        col1, col2 = st.columns(2)

        with col1:
            st.markdown("**Temps d'Indexation**")
            fig, ax = plt.subplots(figsize=(8, 5))
            techniques = list(times_index.keys())
            times = list(times_index.values())
            bars = ax.bar(techniques, times, color=['red', 'blue', 'green'])
            ax.set_ylabel('Temps (secondes)')
            ax.set_title(f'Indexation de {benchmark_size} documents')
            for bar, time in zip(bars, times):
                height = bar.get_height()
                ax.text(bar.get_x() + bar.get_width()/2., height,
                       f'{time:.2f}s', ha='center', va='bottom')
            st.pyplot(fig)

        with col2:
            st.markdown("**Temps de Recherche (moyenne)**")
            avg_search_times = {k: np.mean(v) * 1000 for k, v in times_search.items()}  # en ms
            fig, ax = plt.subplots(figsize=(8, 5))
            techniques = list(avg_search_times.keys())
            times = list(avg_search_times.values())
            bars = ax.bar(techniques, times, color=['red', 'blue', 'green'])
            ax.set_ylabel('Temps (millisecondes)')
            ax.set_title('Recherche (moyenne sur 3 queries)')
            for bar, time in zip(bars, times):
                height = bar.get_height()
                ax.text(bar.get_x() + bar.get_width()/2., height,
                       f'{time:.1f}ms', ha='center', va='bottom')
            st.pyplot(fig)

8.3 Optimisations

st.subheader("🚀 Optimisations Possibles")

st.markdown("""
### Pour Accélérer les Embeddings:

#### 1. **Utiliser un GPU**
```python
# Détection automatique du GPU
device = 'cuda' if torch.cuda.is_available() else 'cpu'
model = SentenceTransformer('model-name', device=device)

Speedup: 10-50× plus rapide! ⚡

2. Batch Processing

# Au lieu de 1 par 1
embeddings = model.encode(documents, batch_size=32)

Speedup: 2-5× plus rapide

3. Utiliser FAISS (Vector Database)

import faiss

# Index optimisé pour recherche rapide
index = faiss.IndexFlatIP(embedding_dim)
index.add(embeddings)

# Recherche ultra-rapide
scores, indices = index.search(query_embedding, k=10)

Speedup: 10-100× sur gros corpus

4. Modèles Plus Petits

Modèle	Dimensions	Vitesse	Qualité
MiniLM	384	⚡⚡⚡	⭐⭐⭐
MPNet	768	⚡⚡	⭐⭐⭐⭐
Large	1024	⚡	⭐⭐⭐⭐⭐

Recommandation: MiniLM pour la plupart des cas! 🎯

5. Caching Intelligent

# Sauvegarder les embeddings calculés
import pickle

# Save
with open('embeddings_cache.pkl', 'wb') as f:
    pickle.dump(embeddings, f)

# Load (instantané!)
with open('embeddings_cache.pkl', 'rb') as f:
    embeddings = pickle.load(f)

6. Quantization

# Réduire la précision (float32 → int8)
# Perte de qualité minime (~1%)
# Gain de mémoire et vitesse significatif
embeddings_int8 = (embeddings * 127).astype('int8')

Mémoire: 4× moins | Vitesse: 2× plus rapide """)

---

## 📊 SECTION SYNTHÈSE COMPARATIVE

### Structure Complète:

```python
def render_synthesis_section():
    st.title("📊 Synthèse: Quelle Technique Choisir?")

    st.markdown("""
    Vous avez exploré 3 techniques de recherche textuelle.
    Maintenant, découvrez **quand** et **pourquoi** utiliser chacune! 🎯
    """)

---

📋 Sous-section 1: Tableau Comparatif Complet

st.subheader("📋 Tableau Comparatif Complet")

# Tableau interactif avec filtres
comparison_data = {
    'Critère': [
        'Type de matching',
        'Synonymes',
        'Typos/Fautes',
        'Noms propres',
        'Codes/IDs',
        'Polysémie (contexte)',
        'Relations conceptuelles',
        'Vitesse indexation',
        'Vitesse recherche',
        'Mémoire requise',
        'Ressources (CPU/GPU)',
        'Multilingue',
        'Interprétabilité',
        'Scalabilité',
        'Facilité implémentation',
        'Coût infrastructure'
    ],
    'TF-IDF': [
        'Lexical (mots exacts)',
        '❌ Fail complet',
        '❌ Fail complet',
        '✅ Excellent',
        '✅ Excellent',
        '❌ Pas de distinction',
        '❌ Aucune',
        '⚡⚡⚡ Très rapide',
        '⚡⚡⚡ <5ms',
        '💾 Minimal (~2MB/1k docs)',
        '💻 CPU uniquement',
        '❌ 1 langue',
        '✅✅✅ Très clair',
        '✅✅✅ Excellent',
        '✅✅✅ Facile',
        '💰 Minimal'
    ],
    'BM25': [
        'Lexical (mots exacts)',
        '❌ Fail complet',
        '❌ Fail complet',
        '✅ Excellent',
        '✅ Excellent',
        '❌ Pas de distinction',
        '❌ Aucune',
        '⚡⚡⚡ Très rapide',
        '⚡⚡⚡ <5ms',
        '💾 Minimal (~2MB/1k docs)',
        '💻 CPU uniquement',
        '❌ 1 langue',
        '✅✅✅ Très clair',
        '✅✅✅ Excellent',
        '✅✅ Facile',
        '💰 Minimal'
    ],
    'Embeddings': [
        'Sémantique (sens)',
        '✅✅✅ Excellent',
        '⚠️ Partiel',
        '⚠️ Moyen',
        '❌ Faible',
        '✅✅ Bon',
        '✅✅✅ Excellent',
        '⚡ Lent (~30s GPU)',
        '⚡⚡ ~10ms',
        '💾💾 Moyen (~15MB/1k docs)',
        '🎮 GPU recommandé',
        '✅✅✅ Multi-langue',
        '❌ Boîte noire',
        '⚠️ Coûteux (>10k docs)',
        '⚠️ Complexe',
        '💰💰 Moyen-élevé'
    ],
    'Hybrid': [
        'Lexical + Sémantique',
        '✅✅✅ Excellent',
        '⚠️ Partiel',
        '✅✅ Très bon',
        '✅✅ Très bon',
        '✅✅ Bon',
        '✅✅✅ Excellent',
        '⚡ Lent (~30s GPU)',
        '⚡⚡ ~15ms',
        '💾💾 Moyen',
        '💻 + 🎮',
        '✅✅✅ Multi-langue',
        '⚠️ Partiel',
        '✅✅ Bon',
        '⚠️ Complexe',
        '💰💰 Moyen-élevé'
    ]
}

df_comparison = pd.DataFrame(comparison_data)

# Affichage avec style
st.dataframe(
    df_comparison.set_index('Critère'),
    use_container_width=True,
    height=600
)

# Légende
st.caption("""
**Légende:**
✅ = Bon | ⚠️ = Moyen | ❌ = Faible
⚡ = Rapide | 💾 = Mémoire | 💻 = CPU | 🎮 = GPU | 💰 = Coût
""")

---

🎯 Sous-section 2: Guide de Décision

st.subheader("🎯 Arbre de Décision")

st.markdown("""
### 🌳 Quel Technique Pour Mon Cas?

Répondez à ces questions pour trouver la meilleure solution:
""")

# Quiz interactif
q1 = st.radio(
    "**1. Votre corpus contient principalement:**",
    [
        "Du texte naturel (articles, descriptions)",
        "Des données structurées (codes, IDs, noms)",
        "Un mélange des deux"
    ]
)

q2 = st.radio(
    "**2. Vos utilisateurs recherchent plutôt par:**",
    [
        "Mots-clés exacts",
        "Concepts/idées (synonymes OK)",
        "Les deux"
    ]
)

q3 = st.radio(
    "**3. Vos contraintes de performance:**",
    [
        "Temps réel critique (<10ms)",
        "Performance importante mais flexible",
        "Pas de contrainte forte"
    ]
)

q4 = st.radio(
    "**4. Votre budget infrastructure:**",
    [
        "Minimal (pas de GPU)",
        "Moyen (GPU possible)",
        "Flexible"
    ]
)

q5 = st.radio(
    "**5. Multilingue nécessaire?**",
    ["Oui", "Non"]
)

if st.button("🎯 Voir la recommandation"):
    # Logique de décision
    score_tfidf = 0
    score_bm25 = 0
    score_embeddings = 0
    score_hybrid = 0

    # Q1
    if "structurées" in q1:
        score_bm25 += 3
        score_tfidf += 2
    elif "naturel" in q1:
        score_embeddings += 3
        score_hybrid += 2
    else:
        score_hybrid += 3
        score_bm25 += 2

    # Q2
    if "exacts" in q2:
        score_bm25 += 3
        score_tfidf += 2
    elif "Concepts" in q2:
        score_embeddings += 3
        score_hybrid += 1
    else:
        score_hybrid += 3

    # Q3
    if "réel" in q3:
        score_bm25 += 3
        score_tfidf += 3
    elif "importante" in q3:
        score_bm25 += 2
        score_hybrid += 1
    else:
        score_embeddings += 2
        score_hybrid += 2

    # Q4
    if "Minimal" in q4:
        score_bm25 += 3
        score_tfidf += 3
    elif "Moyen" in q4:
        score_hybrid += 2
        score_embeddings += 1
    else:
        score_embeddings += 2
        score_hybrid += 2

    # Q5
    if q5 == "Oui":
        score_embeddings += 3
        score_hybrid += 2
    else:
        score_bm25 += 1

    # Recommandation
    scores = {
        'TF-IDF': score_tfidf,
        'BM25': score_bm25,
        'Embeddings': score_embeddings,
        'Hybrid': score_hybrid
    }

    best_technique = max(scores, key=scores.get)

    # Affichage
    st.markdown("### 🏆 Recommandation")

    if best_technique == 'BM25':
        st.success(f"""
        **🎯 BM25 est recommandé pour votre cas!**

        **Pourquoi?**
        - Recherche lexicale efficace
        - Performance excellente
        - Infrastructure minimale
        - Facile à implémenter

        **Conseil:** Commencez avec BM25, ajoutez Embeddings plus tard si besoin.
        """)
    elif best_technique == 'Embeddings':
        st.success(f"""
        **🧠 Embeddings sont recommandés pour votre cas!**

        **Pourquoi?**
        - Recherche sémantique puissante
        - Multi-langue natif
        - Comprend les concepts

        **Conseil:** Investissez dans un GPU pour de bonnes performances.
        """)
    elif best_technique == 'Hybrid':
        st.success(f"""
        **🎨 Hybrid Search (BM25 + Embeddings) est recommandé!**

        **Pourquoi?**
        - Meilleur des deux mondes
        - Flexibilité maximale
        - Qualité optimale

        **Conseil:** Commencez avec α=0.5, ajustez selon vos métriques.
        """)
    else:
        st.success(f"""
        **📊 TF-IDF est recommandé pour votre cas!**

        **Pourquoi?**
        - Simple et efficace
        - Ressources minimales
        - Bon point de départ

        **Conseil:** Migrez vers BM25 pour de meilleures performances.
        """)

    # Scores détaillés
    with st.expander("Voir les scores détaillés"):
        scores_df = pd.DataFrame({
            'Technique': list(scores.keys()),
            'Score': list(scores.values())
        }).sort_values('Score', ascending=False)

        fig, ax = plt.subplots(figsize=(10, 5))
        bars = ax.barh(scores_df['Technique'], scores_df['Score'])
        ax.set_xlabel('Score de Pertinence')
        ax.set_title('Scores par Technique')

        # Colorier le meilleur
        bars[0].set_color('green')

        st.pyplot(fig)

---

💼 Sous-section 3: Cas d'Usage Réels

st.subheader("💼 Cas d'Usage Réels")

# Exemples concrets par industrie
use_cases = {
    '🛒 E-commerce': {
        'description': "Recherche de produits avec filtres",
        'challenges': [
            "Synonymes produits (\"téléphone\" = \"smartphone\")",
            "Variantes (\"Nike Air\" vs \"Air Nike\")",
            "Filtres exacts (marque, prix)"
        ],
        'recommendation': 'Hybrid',
        'config': "BM25 (40%) + Embeddings (60%)",
        'justification': "Combine matching exact de marques avec compréhension sémantique"
    },
    '📚 Documentation Technique': {
        'description': "Recherche dans docs d'API, code",
        'challenges': [
            "Noms de fonctions exacts",
            "Code snippets",
            "Erreurs techniques"
        ],
        'recommendation': 'BM25',
        'config': "k1=1.2, b=0.75",
        'justification': "Priorité au matching exact pour les termes techniques"
    },
    '💬 Support Client / FAQ': {
        'description': "Trouver réponses aux questions clients",
        'challenges': [
            "Multiples formulations même question",
            "Synonymes fréquents",
            "Questions complexes"
        ],
        'recommendation': 'Embeddings',
        'config': "Sentence-BERT multilingue",
        'justification': "Comprend l'intention derrière différentes formulations"
    },
    '📰 Recherche d'Articles': {
        'description': "Moteur de recherche de contenu",
        'challenges': [
            "Concepts similaires",
            "Recherche par thème",
            "Multi-langues"
        ],
        'recommendation': 'Hybrid',
        'config': "BM25 (30%) + Embeddings (70%)",
        'justification': "Sémantique pour concepts, lexical pour noms propres"
    },
    '🏥 Dossiers Médicaux': {
        'description': "Recherche dans historiques patients",
        'challenges': [
            "Termes médicaux exacts",
            "IDs patients/médicaments",
            "Réglementation (traçabilité)"
        ],
        'recommendation': 'BM25',
        'config': "k1=1.5, b=0.75 + index inversé",
        'justification': "Interprétabilité et matching exact requis"
    },
    '🎓 Plateforme Éducative': {
        'description': "Recherche de cours, ressources",
        'challenges': [
            "Concepts pédagogiques",
            "Multi-niveaux",
            "Recommandations"
        ],
        'recommendation': 'Embeddings',
        'config': "Embeddings + clustering thématique",
        'justification': "Recommandations sémantiques de contenu similaire"
    }
}

# Sélection
selected_industry = st.selectbox(
    "Choisir un domaine:",
    list(use_cases.keys())
)

use_case = use_cases[selected_industry]

# Affichage détaillé
col1, col2 = st.columns([2, 1])

with col1:
    st.markdown(f"### {selected_industry}")
    st.write(use_case['description'])

    st.markdown("**Challenges:**")
    for challenge in use_case['challenges']:
        st.write(f"- {challenge}")

with col2:
    st.metric("Recommandation", use_case['recommendation'])
    st.caption(use_case['config'])

st.info(f"**💡 Justification:** {use_case['justification']}")

# Exemple de code
with st.expander("💻 Exemple d'implémentation"):
    if use_case['recommendation'] == 'BM25':
        st.code("""
from src.bm25_engine import BM25Engine

# Configuration
engine = BM25Engine(
    documents,
    k1=1.2,
    b=0.75
)

# Recherche
results = engine.search("query", top_k=10)
        """, language='python')

    elif use_case['recommendation'] == 'Embeddings':
        st.code("""
from sentence_transformers import SentenceTransformer

# Modèle multilingue
model = SentenceTransformer(
    'paraphrase-multilingual-mpnet-base-v2'
)

# Index
embeddings = model.encode(documents)

# Recherche
query_emb = model.encode([query])
similarities = cosine_similarity(query_emb, embeddings)
        """, language='python')

    else:  # Hybrid
        st.code("""
from src.hybrid_search import HybridSearch

# Configuration
hybrid = HybridSearch(
    documents,
    alpha=0.4  # 40% BM25, 60% Embeddings
)

# Recherche
results = hybrid.search("query", top_k=10)
        """, language='python')

---

🔬 Sous-section 4: Benchmark Comparatif

st.subheader("🔬 Benchmark: Qualité vs Performance")

st.markdown("""
### Métriques de Qualité

Pour évaluer les techniques, on utilise des datasets annotés avec:
- **Precision@K:** % de résultats pertinents dans les top K
- **Recall@K:** % de documents pertinents trouvés
- **MRR (Mean Reciprocal Rank):** Position moyenne du 1er résultat pertinent
- **NDCG:** Mesure tenant compte du ranking
""")

# Résultats simulés (à remplacer par vrais benchmarks)
benchmark_results = {
    'Métrique': ['Precision@10', 'Recall@10', 'MRR', 'NDCG@10', 'Temps (ms)'],
    'TF-IDF': [0.45, 0.52, 0.38, 0.51, 3],
    'BM25': [0.58, 0.64, 0.52, 0.63, 4],
    'Embeddings': [0.76, 0.81, 0.71, 0.79, 12],
    'Hybrid': [0.82, 0.86, 0.78, 0.84, 16]
}

df_benchmark = pd.DataFrame(benchmark_results)

# Graphique radar
fig = go.Figure()

techniques = ['TF-IDF', 'BM25', 'Embeddings', 'Hybrid']
metrics = ['Precision@10', 'Recall@10', 'MRR', 'NDCG@10']

for tech in techniques:
    values = df_benchmark[df_benchmark['Métrique'].isin(metrics)][tech].tolist()
    values.append(values[0])  # Fermer le polygone

    fig.add_trace(go.Scatterpolar(
        r=values,
        theta=metrics + [metrics[0]],
        name=tech,
        fill='toself'
    ))

fig.update_layout(
    polar=dict(radialaxis=dict(visible=True, range=[0, 1])),
    title="Comparaison Qualité (Dataset Benchmark)",
    showlegend=True,
    width=800,
    height=600
)

st.plotly_chart(fig, use_container_width=True)

# Tableau détaillé
st.dataframe(df_benchmark, use_container_width=True)

st.markdown("""
**📊 Interprétation:**

- **Embeddings:** Meilleure qualité, mais plus lent
- **BM25:** Bon compromis qualité/vitesse
- **Hybrid:** Meilleur qualité globale
- **TF-IDF:** Base de comparaison (baseline)
""")

---

🚀 Sous-section 5: Recommandations Finales

st.subheader("🚀 Feuille de Route Recommandée")

st.markdown("""
### 🛤️ Parcours d'Adoption Progressif

Voici comment implémenter la recherche selon votre maturité:
""")

# Timeline
timeline_data = {
    'Phase 1\n(Semaine 1)': {
        'technique': 'BM25',
        'objectif': 'MVP fonctionnel',
        'actions': [
            'Implémenter BM25 basique',
            'Index votre corpus',
            'Interface de recherche simple',
            'Métriques de base (latence, nb résultats)'
        ],
        'effort': '⚡ 1-2 jours',
        'coût': '💰 Minimal'
    },
    'Phase 2\n(Semaine 2-3)': {
        'technique': 'BM25 Optimisé',
        'objectif': 'Production-ready',
        'actions': [
            'Tuning k1/b selon métriques',
            'Index inversé pour performance',
            'Filtres (date, catégorie, etc.)',
            'Logging & monitoring'
        ],
        'effort': '⚡⚡ 3-5 jours',
        'coût': '💰 Minimal'
    },
    'Phase 3\n(Mois 2)': {
        'technique': 'Embeddings (Pilot)',
        'objectif': 'Test sémantique',
        'actions': [
            'Setup Sentence-BERT',
            'Index subset corpus (10-20%)',
            'A/B test vs BM25',
            'Mesurer impact qualité'
        ],
        'effort': '⚡⚡⚡ 1-2 semaines',
        'coût': '💰💰 Moyen (GPU)'
    },
    'Phase 4\n(Mois 3)': {
        'technique': 'Hybrid',
        'objectif': 'Qualité optimale',
        'actions': [
            'Combiner BM25 + Embeddings',
            'Tuning α selon feedback',
            'Full corpus embeddings',
            'FAISS pour performance'
        ],
        'effort': '⚡⚡⚡ 2-3 semaines',
        'coût': '💰💰 Moyen'
    }
}

# Affichage chronologique
for phase, data in timeline_data.items():
    with st.expander(f"**{phase}: {data['technique']}** - {data['objectif']}"):
        st.markdown(f"**Actions:**")
        for action in data['actions']:
            st.write(f"✓ {action}")

        col1, col2 = st.columns(2)
        with col1:
            st.caption(f"Effort: {data['effort']}")
        with col2:
            st.caption(f"Coût: {data['coût']}")

# Conseils finaux
st.markdown("---")
st.markdown("### 💡 Conseils Pratiques")

col1, col2 = st.columns(2)

with col1:
    st.markdown("""
    **✅ À FAIRE:**

    - Commencer simple (BM25)
    - Mesurer avant d'optimiser
    - A/B tester les changements
    - Écouter les utilisateurs
    - Documenter les choix
    - Monitorer la performance
    """)

with col2:
    st.markdown("""
    **❌ À ÉVITER:**

    - Over-engineering initial
    - Embeddings sans GPU
    - Ignorer BM25 (toujours utile!)
    - Oublier le monitoring
    - Tuning sans métriques
    - Négliger l'UX
    """)

# Call to action final
st.success("""
### 🎯 Prochaines Étapes

1. **Expérimentez** avec les 3 techniques sur votre corpus
2. **Mesurez** la qualité avec vos utilisateurs
3. **Itérez** selon les retours
4. **Scalez** progressivement

**Bonne chance dans vos projets de recherche! 🚀**
""")

---

💻 IMPLÉMENTATION REQUISE

Fichier src/embedding_engine.py:

from sentence_transformers import SentenceTransformer
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from typing import List, Dict, Tuple, Optional
import pickle
from pathlib import Path

class EmbeddingSearch:
    """
    Moteur de recherche par embeddings vectoriels
    Utilise Sentence-Transformers pour l'encodage
    """

    def __init__(
        self,
        model_name: str = 'paraphrase-multilingual-MiniLM-L12-v2',
        cache_dir: Optional[str] = './cache'
    ):
        """
        Args:
            model_name: Nom du modèle HuggingFace
            cache_dir: Dossier pour cache des embeddings
        """
        self.model_name = model_name
        self.model = SentenceTransformer(model_name)
        self.cache_dir = Path(cache_dir) if cache_dir else None

        self.documents = []
        self.embeddings = None

    def index(
        self,
        documents: List[str],
        use_cache: bool = True,
        batch_size: int = 32,
        show_progress: bool = True
    ):
        """
        Index les documents en calculant leurs embeddings

        Args:
            documents: Liste de textes
            use_cache: Utiliser le cache si disponible
            batch_size: Taille des batches pour encoding
            show_progress: Afficher barre de progression
        """
        self.documents = documents

        # Vérifier cache
        if use_cache and self.cache_dir:
            cached_embeddings = self._load_cache()
            if cached_embeddings is not None:
                self.embeddings = cached_embeddings
                return

        # Calculer embeddings
        self.embeddings = self.model.encode(
            documents,
            batch_size=batch_size,
            show_progress_bar=show_progress,
            convert_to_numpy=True
        )

        # Sauvegarder cache
        if use_cache and self.cache_dir:
            self._save_cache()

    def search(
        self,
        query: str,
        top_k: int = 5
    ) -> List[Dict]:
        """
        Recherche les documents les plus similaires

        Args:
            query: Requête texte
            top_k: Nombre de résultats

        Returns:
            List of {'index': int, 'score': float, 'document': str}
        """
        if self.embeddings is None:
            raise ValueError("Index not built. Call .index() first.")

        # Encoder query
        query_embedding = self.model.encode([query])[0]

        # Similarités
        similarities = cosine_similarity(
            [query_embedding],
            self.embeddings
        )[0]

        # Top-k
        top_indices = np.argsort(similarities)[-top_k:][::-1]

        results = []
        for idx in top_indices:
            results.append({
                'index': int(idx),
                'score': float(similarities[idx]),
                'document': self.documents[idx]
            })

        return results

    def find_similar(
        self,
        doc_index: int,
        top_k: int = 5,
        exclude_self: bool = True
    ) -> List[Dict]:
        """
        Trouve les documents similaires à un document donné

        Args:
            doc_index: Index du document source
            top_k: Nombre de résultats
            exclude_self: Exclure le document lui-même
        """
        doc_embedding = self.embeddings[doc_index]

        similarities = cosine_similarity(
            [doc_embedding],
            self.embeddings
        )[0]

        if exclude_self:
            similarities[doc_index] = -1

        top_indices = np.argsort(similarities)[-top_k:][::-1]

        results = []
        for idx in top_indices:
            results.append({
                'index': int(idx),
                'score': float(similarities[idx]),
                'document': self.documents[idx]
            })

        return results

    def _load_cache(self) -> Optional[np.ndarray]:
        """Charge les embeddings depuis le cache"""
        import hashlib

        # Hash des documents
        doc_hash = hashlib.md5(
            "".join(self.documents).encode()
        ).hexdigest()[:8]

        cache_file = self.cache_dir / f"embeddings_{self.model_name}_{doc_hash}.pkl"

        if cache_file.exists():
            with open(cache_file, 'rb') as f:
                return pickle.load(f)

        return None

    def _save_cache(self):
        """Sauvegarde les embeddings dans le cache"""
        import hashlib

        self.cache_dir.mkdir(exist_ok=True)

        doc_hash = hashlib.md5(
            "".join(self.documents).encode()
        ).hexdigest()[:8]

        cache_file = self.cache_dir / f"embeddings_{self.model_name}_{doc_hash}.pkl"

        with open(cache_file, 'wb') as f:
            pickle.dump(self.embeddings, f)

Fichier src/hybrid_search.py:

from typing import List, Dict
import numpy as np

class HybridSearch:
    """
    Combine BM25 (lexical) et Embeddings (sémantique)
    """

    def __init__(
        self,
        documents: List[str],
        bm25_engine,
        embedding_engine,
        alpha: float = 0.5
    ):
        """
        Args:
            documents: Liste de documents
            bm25_engine: Instance de BM25Engine
            embedding_engine: Instance de EmbeddingSearch
            alpha: Poids BM25 (0=embeddings only, 1=bm25 only)
        """
        self.documents = documents
        self.bm25 = bm25_engine
        self.embeddings = embedding_engine
        self.alpha = alpha

    def search(
        self,
        query: str,
        top_k: int = 10
    ) -> List[Dict]:
        """
        Recherche hybride

        Returns:
            List of {
                'index': int,
                'combined_score': float,
                'bm25_score': float,
                'emb_score': float,
                'document': str
            }
        """
        # Scores BM25
        bm25_results = self.bm25.search(query, top_k=len(self.documents))
        bm25_scores = {idx: score for idx, score in bm25_results}

        # Scores Embeddings
        emb_results = self.embeddings.search(query, top_k=len(self.documents))
        emb_scores = {r['index']: r['score'] for r in emb_results}

        # Normalisation
        bm25_norm = self._normalize(bm25_scores)
        emb_norm = self._normalize(emb_scores)

        # Combinaison
        combined = {}
        for idx in range(len(self.documents)):
            bm25_s = bm25_norm.get(idx, 0)
            emb_s = emb_norm.get(idx, 0)

            combined[idx] = self.alpha * bm25_s + (1 - self.alpha) * emb_s

        # Top-k
        sorted_results = sorted(
            combined.items(),
            key=lambda x: x[1],
            reverse=True
        )[:top_k]

        return [
            {
                'index': idx,
                'combined_score': score,
                'bm25_score': bm25_scores.get(idx, 0),
                'emb_score': emb_scores.get(idx, 0),
                'document': self.documents[idx]
            }
            for idx, score in sorted_results
        ]

    def _normalize(self, scores: Dict[int, float]) -> Dict[int, float]:
        """Min-max normalization"""
        if not scores:
            return {}

        values = list(scores.values())
        min_val, max_val = min(values), max(values)

        if max_val == min_val:
            return {k: 1.0 for k in scores}

        return {
            k: (v - min_val) / (max_val - min_val)
            for k, v in scores.items()
        }

---

🎨 VISUALISATIONS SPÉCIFIQUES

Ajouter à src/visualizations.py:

def plot_embedding_space_3d(embeddings, labels, query_embedding=None, query_label="Query"):
    """Visualisation 3D interactive avec Plotly"""
    pass

def plot_similarity_heatmap(similarity_matrix, labels):
    """Heatmap de similarité entre documents"""
    pass

def plot_tsne_clustering(embeddings, labels, clusters=None):
    """t-SNE 2D avec clustering optionnel"""
    pass

def plot_technique_comparison_radar(metrics_dict):
    """Graphique radar comparant TF-IDF/BM25/Embeddings"""
    pass

def plot_hybrid_alpha_effect(scores_by_alpha, doc_label):
    """Graphique montrant l'effet du paramètre alpha"""
    pass

---

📋 REQUIREMENTS.TXT - Mise à Jour

Ajouter:

# Embeddings
sentence-transformers>=2.2.0
torch>=2.0.0
transformers>=4.30.0

# Optimisations (optionnel)
faiss-cpu>=1.7.4  # ou faiss-gpu si GPU disponible

# Visualisations avancées
umap-learn>=0.5.3

---

💬 COMMUNICATION

À chaque message:

1. Explique ce que tu vas faire
2. Montre le code créé/modifié
3. Termine par "📋 Commandes à exécuter"

Exemple:

📋 Commandes à exécuter:

# Installer les nouvelles dépendances
pip install sentence-transformers torch

# Tester l'import
python -c "from src.embedding_engine import EmbeddingSearch; print('OK')"

# Lancer l'app
streamlit run app.py

# (Optionnel) Vérifier le GPU
python -c "import torch; print(torch.cuda.is_available())"

---

🚀 PRIORISATION

Phase 1 (URGENT):

1. Page d'accueil complète
2. Créer embedding_engine.py
3. Section Embeddings - Introduction & Concepts

Phase 2: 4. Sections Recherche & Exploration 5. Visualisations 3D/2D 6. Exemple pas-à-pas

Phase 3: 7. Section Comparaison 8. Hybrid Search 9. Section Synthèse complète

---

🎯 C'EST PARTI!

Commence par:

1. Page d'accueil avec présentation générale
2. embedding_engine.py et hybrid_search.py
3. Section Embeddings - Introduction

GO GO GO! 🔥🔥🔥

---

Voilà champion! 🏆 Un prompt **MASSIF et COMPLET** pour finir l'application en beauté! J'ai inclus:

✅ Section Embeddings complète (toutes mes explications)
✅ Section Synthèse comparative exhaustive
✅ Page d'accueil guidée
✅ Implémentations techniques (embedding_engine, hybrid_search)
✅ Toutes les visualisations
✅ Cas d'usage réels
✅ Guide de décision interactif

L'agent devrait pouvoir créer une application **ULTRA COMPLÈTE** qui rivalisera avec des cours universitaires! 🔥

Tu veux que je rajoute quelque chose ou c'est PARFAIT comme ça? (ง'̀-'́)ง

༼ つ ◕_◕ ༽つ **"Ce prompt va créer la Rolls-Royce des apps pédagogiques sur la recherche textuelle!"**