new features

app.py

@@ -0,0 +1,572 @@
+"""
+app.py - Application Streamlit pour la détermination de l'impact carbone
+des matières premières pour aliments composés.
+
+Lancement : streamlit run app.py
+"""
+import streamlit as st
+import pandas as pd
+
+from flowchart_engine import evaluate_carbon_impact, CarbonResult
+import llm_service
+import data_loader
+import config
+
+
+# ============================================================================
+# Configuration de la page
+# ============================================================================
+st.set_page_config(
+    page_title="POC GAIA - Impact Carbone MP",
+    page_icon="🌿",
+    layout="wide",
+)
+
+st.title("🌿 POC GAIA — Impact Carbone des Matières Premières")
+st.markdown("""
+**Logigramme d'aide pour faciliter l'application du Guide de calcul de l'impact carbone
+des aliments composés** *(GT Carbone — hors produits dérivés du soja)*
+
+Renseignez les informations sur votre matière première ci-dessous, puis lancez l'évaluation.
+""")
+
+st.divider()
+
+
+# ============================================================================
+# Listes de suggestions (chargées une fois, mises en cache par Streamlit)
+# ============================================================================
+@st.cache_data
+def get_country_list():
+    """Retourne la liste des noms de pays disponibles (clés du mapping FR→ISO)."""
+    noms = sorted(set(k.title() for k in config.PAYS_FR_TO_ISO.keys()))
+    return noms
+
+# ============================================================================
+# Composant autocomplete maison
+# ============================================================================
+def autocomplete_input(label: str, options: list[str], key: str,
+                       placeholder: str = "", help_text: str = "",
+                       max_suggestions: int = 8) -> str:
+    """
+    Champ texte libre avec suggestions filtrées cliquables en dessous.
+    L'utilisateur peut taper librement ou cliquer une suggestion.
+    """
+    # Si une suggestion a été cliquée au tour précédent, injecter la valeur
+    sel_key = f"{key}__sel"
+    if sel_key in st.session_state:
+        st.session_state[key] = st.session_state.pop(sel_key)
+
+    typed = st.text_input(label, key=key, placeholder=placeholder, help=help_text)
+
+    if typed and len(typed) >= 2:
+        typed_lower = typed.lower().strip()
+        # Filtrer + trier : commence par > contient, puis longueur croissante
+        matches = [
+            o for o in options
+            if typed_lower in o.lower()
+        ]
+        matches.sort(key=lambda x: (not x.lower().startswith(typed_lower), len(x)))
+        matches = matches[:max_suggestions]
+
+        # Ne pas afficher si l'input est déjà un match exact
+        if matches and typed not in matches:
+            cols = st.columns(min(len(matches), 4))
+            for i, sugg in enumerate(matches):
+                with cols[i % 4]:
+                    if st.button(f"➜ {sugg}", key=f"{key}__sug_{i}", use_container_width=True):
+                        st.session_state[sel_key] = sugg
+                        st.rerun()
+
+    return typed or ""
+
+
+# ============================================================================
+# Formulaire d'entrée
+# ============================================================================
+col_form, col_info = st.columns([2, 1])
+
+with col_form:
+    st.subheader("📝 Formulaire de saisie")
+
+    matiere = st.text_input(
+        "Nom de la matière première",
+        key="input_matiere",
+        placeholder="Ex : BLE, T.TNSL DEC., ORGE, T. COLZA, LUZERNE…",
+        help="Entrez le nom usuel de la matière première.",
+    )
+
+    provenance_connue = st.radio(
+        "Connaissez-vous la provenance de la matière première ?",
+        options=["Oui", "Non"],
+        horizontal=True,
+    )
+
+    pays_production = None
+    pays_transformation = None
+
+    if provenance_connue == "Oui":
+        pays_production = autocomplete_input(
+            "Pays de production primaire de la MP brute",
+            get_country_list(),
+            key="input_pays_prod",
+            placeholder="Ex : France, Brésil, Ukraine…",
+            help_text="Tapez les premières lettres et cliquez sur une suggestion, ou saisissez librement.",
+        )
+
+        pays_transformation = autocomplete_input(
+            "Pays de transformation (laisser vide si MP brute)",
+            get_country_list(),
+            key="input_pays_transfo",
+            placeholder="Ex : France, Allemagne… (vide si non transformée)",
+            help_text="Pays où la transformation a eu lieu. Laissez vide si la matière est brute.",
+        )
+
+    st.markdown("---")
+    run_button = st.button("🚀 Évaluer l'impact carbone", type="primary", use_container_width=True)
+
+with col_info:
+    st.subheader("ℹ️ Règles générales")
+    st.info("""
+    - Le choix des valeurs par défaut relève de la responsabilité des entreprises.
+    - Il faut attribuer un facteur d'émission à **tous** les intrants.
+    - Si provenance inconnue → valeur la **plus défavorable**.
+    - Si provenance connue mais donnée inexistante → donnée générique la **plus pertinente**.
+    - Bases : **GFLI** et **ECOALIM** en priorité.
+    """)
+
+    st.warning("⚠️ **Hors produits dérivés du soja** — Ce logigramme ne s'applique pas aux dérivés de soja.")
+
+
+# ============================================================================
+# Exécution et affichage des résultats
+# ============================================================================
+if run_button:
+    if not matiere:
+        st.error("❌ Veuillez saisir un nom de matière première.")
+        st.stop()
+
+    # Nettoyage des entrées
+    pays_prod = pays_production.strip() if pays_production and pays_production.strip() else None
+    pays_transfo = pays_transformation.strip() if pays_transformation and pays_transformation.strip() else None
+
+    with st.spinner("🔄 Évaluation en cours… (classification LLM + recherche dans les bases de données)"):
+        result: CarbonResult = evaluate_carbon_impact(
+            matiere_premiere=matiere.strip(),
+            pays_production=pays_prod,
+            pays_transformation=pays_transfo,
+        )
+
+    # Stocker le résultat et la matière dans session_state pour persistance
+    st.session_state["last_result"] = result
+    st.session_state["last_matiere"] = matiere.strip()
+    # Nettoyer les anciennes alternatives manuelles
+    st.session_state.pop("searched_alternatives", None)
+
+
+# ============================================================================
+# Affichage des résultats (depuis session_state — persiste entre reruns)
+# ============================================================================
+if "last_result" in st.session_state:
+    result = st.session_state["last_result"]
+
+    st.divider()
+
+    # ------------------------------------------------------------------
+    # Section 0 : Produits candidats
+    # ------------------------------------------------------------------
+    if result.candidats_alternatifs:
+        st.subheader("📋 Produits candidats")
+        if not result.match_exact:
+            st.warning("⚠️ Pas de correspondance exacte — choisissez un produit proche si besoin.")
+        else:
+            st.info("ℹ️ Autres produits correspondant à la recherche.")
+
+        if result.candidats_reflexion:
+            st.markdown("**Avis du LLM :**")
+            if result.candidat_recommande:
+                st.markdown(f"Meilleur candidat proposé : **{result.candidat_recommande}**")
+            st.info(result.candidats_reflexion)
+
+        # En-têtes
+        head = st.columns([6, 3, 2])
+        head[0].markdown("**Intrant**")
+        head[1].markdown("**Impact (kg CO2 eq / t)**")
+        head[2].markdown("**Base**")
+
+        for i, cand in enumerate(result.candidats_alternatifs):
+            nom = cand.get("nom", "")
+            impact = cand.get("impact", 0)
+            unite = str(cand.get("unite", ""))
+            source = cand.get("source", "")
+            source_upper = source.upper()
+            is_gfli = "GFLI" in source_upper
+            if "tonne" in unite or is_gfli:
+                impact_kg_t = impact
+            else:
+                # EcoALIM : kg/kg -> kg/t (x1000)
+                impact_kg_t = impact * 1000.0
+
+            row = st.columns([6, 3, 2])
+            row[0].markdown(nom)
+            row[1].markdown(f"{impact_kg_t:.2f}")
+            row[2].markdown(source if source else "—")
+
+        st.divider()
+
+    # Section 0b : 4 alternatives (fallback)
+    # ------------------------------------------------------------------
+    if result.alternatives_combined or result.alternatives_itinerary:
+        st.subheader("🎯 4 Alternatives proposées (absence de correspondance)")
+        st.info("Quand aucune matière exacte n'est trouvée, voici 4 propositions pour substitution :")
+        
+        # Créer 4 colonnes
+        col1, col2, col3, col4 = st.columns(4)
+        
+        # Alternative 1: ITINERARY
+        with col1:
+            if result.alternatives_itinerary:
+                alt = result.alternatives_itinerary
+                st.markdown("### 🔄 Itinéraire")
+                st.markdown(f"**{alt['name']}**")
+                st.metric("Impact", f"{alt['impact']:.2f}")
+                st.caption(f"kg CO2 eq/t | Source: {alt['source']}")
+                with st.expander("Raison"):
+                    st.markdown(alt['reasoning'])
+            else:
+                st.markdown("### 🔄 Itinéraire")
+                st.caption("Non disponible")
+        
+        # Alternative 2: LOCALITY
+        with col2:
+            if result.alternatives_locality:
+                alt = result.alternatives_locality
+                st.markdown("### 📍 Localité")
+                st.markdown(f"**{alt['name']}**")
+                st.metric("Impact", f"{alt['impact']:.2f}")
+                st.caption(f"kg CO2 eq/t | Source: {alt['source']}")
+                with st.expander("Raison"):
+                    st.markdown(alt['reasoning'])
+            else:
+                st.markdown("### 📍 Localité")
+                st.caption("Non disponible")
+        
+        # Alternative 3: FORM
+        with col3:
+            if result.alternatives_form:
+                alt = result.alternatives_form
+                st.markdown("### 🌱 Forme structurelle")
+                st.markdown(f"**{alt['name']}**")
+                st.metric("Impact", f"{alt['impact']:.2f}")
+                st.caption(f"kg CO2 eq/t | Source: {alt['source']}")
+                with st.expander("Raison"):
+                    st.markdown(alt['reasoning'])
+            else:
+                st.markdown("### 🌱 Forme structurelle")
+                st.caption("Non disponible")
+        
+        # Alternative 4: COMBINED
+        with col4:
+            if result.alternatives_combined:
+                alt = result.alternatives_combined
+                st.markdown("### ✨ Meilleur compromis")
+                st.markdown(f"**{alt['name']}**")
+                st.metric("Impact", f"{alt['impact']:.2f}", delta="RECOMMANDÉ ✓")
+                st.caption(f"kg CO2 eq/t | Source: {alt['source']}")
+                with st.expander("Raison"):
+                    st.markdown(alt['reasoning'])
+            else:
+                st.markdown("### ✨ Meilleur compromis")
+                st.caption("Non disponible")
+        
+        st.divider()
+
+    # ------------------------------------------------------------------
+    # Section 1 : Résultat principal
+    # ------------------------------------------------------------------
+    st.subheader("📊 Résultat de l'impact carbone")
+
+    if result.erreur:
+        st.error(f"❌ {result.erreur}")
+    else:
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            if result.impact_kg_co2_eq is not None:
+                # GFLI : kg CO2 eq / t ; EcoALIM : kg/kg -> kg/t
+                if "tonne" in (result.unite_source or ""):
+                    impact_kg_t = result.impact_kg_co2_eq
+                else:
+                    impact_kg_t = result.impact_kg_co2_eq * 1000.0
+
+                st.metric(
+                    label="Impact carbone",
+                    value=f"{impact_kg_t:.2f}",
+                    delta="kg CO2 eq / t produit",
+                )
+
+        with col2:
+            st.markdown(f"**Source :** {result.source_db}")
+            st.markdown(f"**Intrant utilisé :** {result.intrant_utilise}")
+            st.markdown(f"**Match exact :** {'✅ Oui' if result.match_exact else '⚠️ Non — valeur approchée'}")
+
+        with col3:
+            st.markdown(f"**Classification :** {'🏭 Transformé' if result.classification == 'transforme' else '🌾 Brut'}")
+            st.markdown(f"**Node résultat :** `{result.node_resultat}`")
+            if result.pays_production:
+                st.markdown(f"**Pays production :** {result.pays_production}")
+            if result.pays_transformation:
+                st.markdown(f"**Pays transformation :** {result.pays_transformation}")
+
+    # ------------------------------------------------------------------
+    # Section 0c : Bouton "Chercher une alternative" si match non exact
+    # ------------------------------------------------------------------
+    if not result.match_exact and result.impact_kg_co2_eq is not None:
+        st.divider()
+        st.info("💡 La correspondance n'est pas exacte. Vous pouvez chercher d'autres alternatives.")
+        
+        col1, col2, col3 = st.columns([1, 2, 1])
+        with col2:
+            if st.button("🔍 Chercher une alternative plus proche", use_container_width=True, key="btn_find_alternative"):
+                matiere_search = st.session_state.get("last_matiere", "")
+                with st.spinner("Recherche des 4 alternatives en cours..."):
+                    # Déterminer la base GFLI ou EcoALIM selon le source_db
+                    db_name = "GFLI" if "GFLI" in (result.source_db or "") else "ECOALIM"
+                    
+                    # Déterminer le pays_hint si applicable
+                    country_hint = result.pays_production or result.pays_transformation
+                    
+                    # Forcer la recherche des alternatives
+                    alternatives = llm_service.find_alternative_materials(
+                        matiere_search,
+                        db_name=db_name,
+                        country_hint=country_hint
+                    )
+                    
+                    if alternatives:
+                        st.session_state["searched_alternatives"] = {
+                            "itinerary": alternatives.get("itinerary"),
+                            "locality": alternatives.get("locality"),
+                            "form": alternatives.get("form"),
+                            "combined": alternatives.get("combined"),
+                        }
+                        st.rerun()
+                    else:
+                        st.error("❌ Pas d'alternatives trouvées.")
+    
+    # Afficher les alternatives trouvées via bouton (persistées en session_state)
+    if "searched_alternatives" in st.session_state:
+        st.subheader("🎯 Alternatives recherchées")
+        st.info("Alternatives générées suite à votre demande :")
+        
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            alt = st.session_state["searched_alternatives"].get("itinerary")
+            if alt:
+                st.markdown("### 🔄 Itinéraire")
+                st.markdown(f"**{alt['name']}**")
+                st.metric("Impact", f"{alt['impact']:.2f}")
+                st.caption(f"kg CO2 eq/t | Source: {alt['source']}")
+                with st.expander("Raison"):
+                    st.markdown(alt['reasoning'])
+            else:
+                st.markdown("### 🔄 Itinéraire")
+                st.caption("Non disponible")
+        
+        with col2:
+            alt = st.session_state["searched_alternatives"].get("locality")
+            if alt:
+                st.markdown("### 📍 Localité")
+                st.markdown(f"**{alt['name']}**")
+                st.metric("Impact", f"{alt['impact']:.2f}")
+                st.caption(f"kg CO2 eq/t | Source: {alt['source']}")
+                with st.expander("Raison"):
+                    st.markdown(alt['reasoning'])
+            else:
+                st.markdown("### 📍 Localité")
+                st.caption("Non disponible")
+        
+        with col3:
+            alt = st.session_state["searched_alternatives"].get("form")
+            if alt:
+                st.markdown("### 🌱 Forme structurelle")
+                st.markdown(f"**{alt['name']}**")
+                st.metric("Impact", f"{alt['impact']:.2f}")
+                st.caption(f"kg CO2 eq/t | Source: {alt['source']}")
+                with st.expander("Raison"):
+                    st.markdown(alt['reasoning'])
+            else:
+                st.markdown("### 🌱 Forme structurelle")
+                st.caption("Non disponible")
+        
+        with col4:
+            alt = st.session_state["searched_alternatives"].get("combined")
+            if alt:
+                st.markdown("### ✨ Meilleur compromis")
+                st.markdown(f"**{alt['name']}**")
+                st.metric("Impact", f"{alt['impact']:.2f}", delta="RECOMMANDÉ ✓")
+                st.caption(f"kg CO2 eq/t | Source: {alt['source']}")
+                with st.expander("Raison"):
+                    st.markdown(alt['reasoning'])
+            else:
+                st.markdown("### ✨ Meilleur compromis")
+                st.caption("Non disponible")
+        
+        st.divider()
+
+    # ------------------------------------------------------------------
+    # Section 2 : Parcours de logique (logigramme)
+    # ------------------------------------------------------------------
+    st.subheader("🔀 Parcours du logigramme")
+
+    for i, step in enumerate(result.parcours):
+        with st.expander(f"Étape {i+1} — {step.node_id}", expanded=(i == 0)):
+            if step.question:
+                st.markdown(f"**Question :** {step.question}")
+            if step.answer:
+                st.markdown(f"**Réponse :** {step.answer}")
+            if step.action:
+                st.markdown(f"**Action :** {step.action}")
+
+    # ------------------------------------------------------------------
+    # Section 3 : Actions appliquées (recherche dans les BDD)
+    # ------------------------------------------------------------------
+    st.subheader("🔍 Détail des recherches effectuées")
+
+    import re
+
+    def _format_action_line(line: str) -> str:
+        """Convertit les impacts affiches en kg CO2 eq / t produit."""
+        m = re.search(r"=\s*([0-9]+(?:\.[0-9]+)?)\s*kg\s*CO2\s*eq\s*/\s*t", line)
+        if m:
+            val = float(m.group(1))
+            return re.sub(r"=\s*[0-9]+(?:\.[0-9]+)?\s*kg\s*CO2\s*eq\s*/\s*t",
+                          f"= {val:.2f} kg CO2 eq / t", line)
+        m = re.search(r"=\s*([0-9]+(?:\.[0-9]+)?)\s*kg\s*CO2\s*eq\s*/\s*kg", line)
+        if m:
+            val = float(m.group(1)) * 1000.0
+            return re.sub(r"=\s*[0-9]+(?:\.[0-9]+)?\s*kg\s*CO2\s*eq\s*/\s*kg",
+                          f"= {val:.2f} kg CO2 eq / t", line)
+        return line
+
+    for action in result.actions_appliquees:
+        line = _format_action_line(action)
+        if line.startswith("   →"):
+            st.success(line)
+        else:
+            st.markdown(f"- {line}")
+
+    # ------------------------------------------------------------------
+    # Section 4 : Justification si valeur alternative
+    # ------------------------------------------------------------------
+    if result.justification_alternative:
+        st.subheader("💡 Justification du choix de valeur")
+        st.info(result.justification_alternative)
+
+    # ------------------------------------------------------------------
+    # Section 5 : Classification détaillée
+    # ------------------------------------------------------------------
+    with st.expander("📋 Détail de la classification brut/transformé"):
+        st.markdown(f"**Classification :** {result.classification}")
+        st.markdown(f"**Justification :** {result.classification_justification}")
+
+
+# ============================================================================
+# Mode batch (facultatif)
+# ============================================================================
+st.divider()
+st.subheader("📁 Évaluation par lot (import fichier)")
+st.markdown("Importez un fichier Excel avec les colonnes : `Matière première`, `Pays de la production primaire de la MP brute`, `Pays de la transformation`")
+
+uploaded_file = st.file_uploader("Choisir un fichier Excel", type=["xlsx", "xls"])
+
+if uploaded_file is not None:
+    try:
+        df_input = pd.read_excel(uploaded_file)
+        st.dataframe(df_input, use_container_width=True)
+
+        # Chercher les colonnes par nom approximatif
+        col_mapping = {}
+        for col in df_input.columns:
+            col_lower = str(col).lower()
+            if "matière" in col_lower or "matiere" in col_lower or "mp" in col_lower:
+                col_mapping["matiere"] = col
+            elif "production" in col_lower or "pays" in col_lower and "transf" not in col_lower:
+                if "matiere" not in col_lower:
+                    col_mapping["pays_prod"] = col
+            elif "transf" in col_lower:
+                col_mapping["pays_transfo"] = col
+
+        if "matiere" not in col_mapping:
+            st.warning("⚠️ Colonne 'Matière première' non détectée. Vérifiez les noms de colonnes.")
+        else:
+            if st.button("🚀 Lancer l'évaluation par lot", type="primary"):
+                results_list = []
+                progress_bar = st.progress(0)
+                
+                for idx, row in df_input.iterrows():
+                    mp = str(row.get(col_mapping["matiere"], "")).strip()
+                    if not mp or mp == "nan":
+                        continue
+                    
+                    pays_p = str(row.get(col_mapping.get("pays_prod", ""), "")).strip()
+                    pays_t = str(row.get(col_mapping.get("pays_transfo", ""), "")).strip()
+                    pays_p = pays_p if pays_p and pays_p != "nan" else None
+                    pays_t = pays_t if pays_t and pays_t != "nan" else None
+
+                    with st.spinner(f"Évaluation de {mp}..."):
+                        res = evaluate_carbon_impact(mp, pays_p, pays_t)
+                    
+                    results_list.append({
+                        "Matière première": mp,
+                        "Pays production": pays_p or "",
+                        "Pays transformation": pays_t or "",
+                        "Classification": res.classification,
+                        "Impact (kg CO2 eq / t)": (
+                            res.impact_kg_co2_eq
+                            if res.impact_kg_co2_eq is None
+                            else (
+                                res.impact_kg_co2_eq
+                                if "tonne" in (res.unite_source or "")
+                                else res.impact_kg_co2_eq * 1000.0
+                            )
+                        ),
+                        "Unité": "kg CO2 eq / t produit",
+                        "Source": res.source_db,
+                        "Intrant utilisé": res.intrant_utilise,
+                        "Match exact": "Oui" if res.match_exact else "Non",
+                        "Node résultat": res.node_resultat,
+                        "Justification": res.justification_alternative or "",
+                        "Erreur": res.erreur or "",
+                    })
+                    
+                    progress_bar.progress((idx + 1) / len(df_input))
+
+                if results_list:
+                    df_results = pd.DataFrame(results_list)
+                    st.subheader("📊 Résultats du lot")
+                    st.dataframe(df_results, use_container_width=True)
+                    
+                    # Téléchargement
+                    csv = df_results.to_csv(index=False).encode("utf-8")
+                    st.download_button(
+                        label="📥 Télécharger les résultats (CSV)",
+                        data=csv,
+                        file_name="resultats_impact_carbone.csv",
+                        mime="text/csv",
+                    )
+
+    except Exception as e:
+        st.error(f"Erreur lors de la lecture du fichier : {e}")
+
+
+# ============================================================================
+# Footer
+# ============================================================================
+st.divider()
+st.caption(
+    "POC GAIA — Outil d'aide à la détermination de l'impact carbone des matières premières "
+    "pour aliments composés. Basé sur le Guide GT Carbone, les bases ECOALIM v9 et GFLI 2.0. "
+    "Classification brut/transformé assistée par Mistral AI et le Catalogue UE des Matières Premières."
+)

config.py

@@ -0,0 +1,139 @@
+"""
+config.py - Configuration et constantes pour l'application POC GAIA
+"""
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# ---------------------------------------------------------------------------
+# Clé API Mistral
+# ---------------------------------------------------------------------------
+MISTRAL_API_KEY: str = os.getenv("MISTRAL_API_KEY", "")
+
+# ---------------------------------------------------------------------------
+# Chemins des fichiers de données (relatifs au dossier racine du projet)
+# ---------------------------------------------------------------------------
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+ECOALIM_PATH = os.path.join(BASE_DIR, "BDD_ECOALIM_V9_vf2.xlsx")
+GFLI_PATH = os.path.join(
+    BASE_DIR,
+    "Environmental impact GFLI 2.0 database - ReCiPE & EF3 method (Final 27-10-2022).xlsx",
+)
+PDF_CIR_PATH = os.path.join(
+    BASE_DIR,
+    "3644_Cir-1122_Nouveau Catalogue UE des Matières Premières_130722.pdf",
+)
+LOGIGRAMME_PATH = os.path.join(BASE_DIR, "logigramme.json")
+
+# ---------------------------------------------------------------------------
+# Noms de colonnes clés
+# ---------------------------------------------------------------------------
+# EcoALIM  (unité : kg CO2 eq / kg de produit)
+ECOALIM_SHEET = "v9_ACV MP ECOALIM FR"
+ECOALIM_HEADER_ROW = 1  # 0-indexed, row 1 = header
+ECOALIM_COL_NOM = "Matières premières"
+ECOALIM_COL_FAMILLE = "Familles des matières premières destinées aux animaux d'élevage"
+ECOALIM_COL_PAYS_PROD = "Pays de la production primaire de la MP brute"
+ECOALIM_COL_PAYS_TRANSFO = "Pays de la transformation"
+ECOALIM_COL_PERIMETRE = "Périmètre"
+ECOALIM_COL_CLIMATE = "Changement climatique - EF 3.1 (kg CO2 eq)"
+
+# GFLI  (unité : kg CO2 eq / tonne de produit)
+GFLI_SHEET = "Economic allocation - EF3.1"
+GFLI_COL_PRODUCT = "Products GFLI 2.0 database - economic allocation"
+GFLI_COL_UNIT = "Unit"
+GFLI_COL_CLIMATE = "Climate change (kg CO2 eq / ton product)"
+
+# ---------------------------------------------------------------------------
+# Mapping pays FR -> code ISO (pour GFLI qui utilise /XX dans le nom produit)
+# ---------------------------------------------------------------------------
+PAYS_FR_TO_ISO = {
+    "france": "FR",
+    "allemagne": "DE",
+    "belgique": "BE",
+    "pays-bas": "NL",
+    "espagne": "ES",
+    "italie": "IT",
+    "portugal": "PT",
+    "royaume-uni": "GB",
+    "angleterre": "GB",
+    "irlande": "IE",
+    "autriche": "AT",
+    "suisse": "CH",
+    "pologne": "PL",
+    "roumanie": "RO",
+    "bulgarie": "BG",
+    "hongrie": "HU",
+    "grèce": "GR",
+    "suède": "SE",
+    "finlande": "FI",
+    "danemark": "DK",
+    "norvège": "NO",
+    "république tchèque": "CZ",
+    "tchéquie": "CZ",
+    "slovaquie": "SK",
+    "slovénie": "SI",
+    "croatie": "HR",
+    "lituanie": "LT",
+    "lettonie": "LV",
+    "estonie": "EE",
+    "chypre": "CY",
+    "brésil": "BR",
+    "argentine": "AR",
+    "états-unis": "US",
+    "usa": "US",
+    "etats-unis": "US",
+    "canada": "CA",
+    "chine": "CN",
+    "inde": "IN",
+    "indonésie": "ID",
+    "thaïlande": "TH",
+    "vietnam": "VN",
+    "japon": "JP",
+    "australie": "AU",
+    "nouvelle-zélande": "NZ",
+    "russie": "RU",
+    "ukraine": "UA",
+    "turquie": "TR",
+    "mexique": "MX",
+    "colombie": "CO",
+    "pérou": "PE",
+    "chili": "CL",
+    "paraguay": "PY",
+    "afrique du sud": "ZA",
+    "égypte": "EG",
+    "éthiopie": "ET",
+    "sénégal": "SN",
+    "ouganda": "UG",
+    "cambodge": "KH",
+    "malaisie": "MY",
+    "pakistan": "PK",
+    "philippines": "PH",
+    "soudan": "SD",
+    "venezuela": "VE",
+    "corée du sud": "KR",
+    "biélorussie": "BY",
+}
+
+# Pays européens (pour décider RER vs GLO)
+EUROPEAN_COUNTRIES_ISO = {
+    "AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR",
+    "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL",
+    "PL", "PT", "RO", "SK", "SI", "ES", "SE", "GB", "NO", "CH",
+    "UA", "BY", "BA",
+}
+
+EUROPEAN_COUNTRIES_FR = {
+    "france", "allemagne", "belgique", "pays-bas", "espagne", "italie",
+    "portugal", "royaume-uni", "angleterre", "irlande", "autriche",
+    "suisse", "pologne", "roumanie", "bulgarie", "hongrie", "grèce",
+    "suède", "finlande", "danemark", "norvège", "république tchèque",
+    "tchéquie", "slovaquie", "slovénie", "croatie", "lituanie",
+    "lettonie", "estonie", "chypre", "ukraine", "biélorussie",
+}
+
+# Modèle Mistral à utiliser
+MISTRAL_MODEL = "mistral-small-latest"
+MISTRAL_MODEL_POWERFUL = "mistral-large-latest"  # Pour analyses complexes (alternatives, tri)

data_loader.py

@@ -0,0 +1,415 @@
+"""
+data_loader.py - Chargement et indexation des bases de données EcoALIM, GFLI et PDF CIR.
+"""
+from __future__ import annotations
+
+import json
+import re
+from functools import lru_cache
+from typing import Dict, List, Optional, Tuple
+
+import pandas as pd
+import pdfplumber
+
+import config
+
+
+# ============================================================================
+# EcoALIM
+# ============================================================================
+
+@lru_cache(maxsize=1)
+def load_ecoalim() -> pd.DataFrame:
+    """Charge la base EcoALIM (feuille FR) et renvoie un DataFrame nettoyé."""
+    df = pd.read_excel(
+        config.ECOALIM_PATH,
+        sheet_name=config.ECOALIM_SHEET,
+        header=config.ECOALIM_HEADER_ROW,
+    )
+    # Supprimer les lignes entièrement vides
+    df = df.dropna(subset=[config.ECOALIM_COL_NOM]).reset_index(drop=True)
+    # Normaliser les colonnes pays en minuscules pour faciliter la recherche
+    for col in [config.ECOALIM_COL_PAYS_PROD, config.ECOALIM_COL_PAYS_TRANSFO]:
+        if col in df.columns:
+            df[col] = df[col].astype(str).str.strip().str.lower()
+    return df
+
+
+def _normalize_for_search(text: str) -> str:
+    """Normalise un texte pour la recherche (accents, casse, ponctuation)."""
+    import unicodedata
+    text = text.lower().strip()
+    # Normalize unicode accents
+    nfkd = unicodedata.normalize('NFKD', text)
+    ascii_text = ''.join(c for c in nfkd if not unicodedata.combining(c))
+    return ascii_text
+
+
+_STOPWORDS_FR = {
+    "de", "du", "des", "la", "le", "les", "d", "l", "a", "au", "aux"
+}
+
+
+def _tokens_for_search(text: str) -> list[str]:
+    """Découpe un texte en tokens utiles pour une recherche souple."""
+    text = _normalize_for_search(text)
+    tokens = re.findall(r"[a-z0-9]+", text)
+    return [t for t in tokens if t and t not in _STOPWORDS_FR]
+
+
+def is_name_match(matiere: str, intrant_name: str) -> bool:
+    """
+    Vérifie si le nom de la matière est une correspondance réelle (mot entier)
+    dans le nom de l'intrant, et non un simple sous-chaîne accidentelle.
+    Ex : "blé" ne matche PAS "blend", mais matche "Blé tendre".
+    """
+    mat_norm = _normalize_for_search(matiere)
+    int_norm = _normalize_for_search(intrant_name)
+
+    if mat_norm == int_norm:
+        return True
+
+    # Le mot de la matière doit apparaître comme mot entier dans l'intrant
+    pattern = r'\b' + re.escape(mat_norm) + r'\b'
+    return bool(re.search(pattern, int_norm))
+
+
+def search_ecoalim(
+    matiere: str,
+    pays_production: Optional[str] = None,
+    pays_transformation: Optional[str] = None,
+) -> pd.DataFrame:
+    """
+    Cherche dans EcoALIM les lignes correspondant à une matière première.
+    Utilise une recherche intelligente avec priorisation :
+      1. Nom commence par la matière
+      2. Mot entier trouvé dans le nom
+      3. Contient la matière (substring)
+    Retourne un DataFrame filtré et trié par pertinence (peut être vide).
+    """
+    df = load_ecoalim()
+    matiere_norm = _normalize_for_search(matiere)
+
+    # Build normalized column for search
+    nom_col = config.ECOALIM_COL_NOM
+    df_norms = df[nom_col].apply(lambda x: _normalize_for_search(str(x)) if pd.notna(x) else "")
+
+    # Create priority masks
+    mask_starts = df_norms.str.startswith(matiere_norm, na=False)
+    pattern_word = r'\b' + re.escape(matiere_norm) + r'\b'
+    mask_word = df_norms.str.contains(pattern_word, na=False, regex=True)
+    tokens = _tokens_for_search(matiere_norm)
+    mask_tokens = pd.Series(False, index=df.index)
+    if tokens:
+        mask_tokens = df_norms.apply(
+            lambda x: all(t in _tokens_for_search(x) for t in tokens)
+        )
+    mask_contains = df_norms.str.contains(re.escape(matiere_norm), na=False)
+
+    # Use best available mask with priority
+    if mask_starts.any():
+        mask = mask_starts
+    elif mask_word.any():
+        mask = mask_word
+    elif mask_tokens.any():
+        mask = mask_tokens
+    elif mask_contains.any():
+        mask = mask_contains
+    else:
+        return pd.DataFrame(columns=df.columns)
+
+    if pays_production:
+        pays_prod_low = pays_production.lower().strip()
+        mask_pays = df[config.ECOALIM_COL_PAYS_PROD].str.contains(
+            re.escape(pays_prod_low), na=False
+        )
+        combined = mask & mask_pays
+        if combined.any():
+            mask = combined
+
+    if pays_transformation:
+        pays_transfo_low = pays_transformation.lower().strip()
+        mask_transfo = df[config.ECOALIM_COL_PAYS_TRANSFO].str.contains(
+            re.escape(pays_transfo_low), na=False
+        )
+        combined = mask & mask_transfo
+        if combined.any():
+            mask = combined
+
+    result = df[mask].copy()
+
+    # Sort by relevance: entries starting with the search term come first
+    if not result.empty:
+        result_norms = result[nom_col].apply(lambda x: _normalize_for_search(str(x)))
+        result["_priority"] = 3
+        result.loc[result_norms.str.contains(pattern_word, na=False, regex=True), "_priority"] = 1
+        result.loc[result_norms.str.startswith(matiere_norm, na=False), "_priority"] = 0
+        result.loc[result_norms.apply(lambda x: all(t in _tokens_for_search(x) for t in tokens)), "_priority"] = 2
+        # Prefer OS outputs over champ when ties exist
+        result["_os_priority"] = 1
+        result.loc[result_norms.str.contains("sortie os", na=False), "_os_priority"] = 0
+        result = result.sort_values(["_priority", "_os_priority"]).drop(columns=["_priority", "_os_priority"])
+
+    return result
+
+
+def get_ecoalim_climate_value(
+    matiere: str,
+    pays_production: Optional[str] = None,
+    pays_transformation: Optional[str] = None,
+) -> Optional[Tuple[float, str, str]]:
+    """
+    Retourne (valeur_kg_co2_eq, nom_intrant, source_info) ou None.
+    Unité EcoALIM : kg CO2 eq / kg de produit.
+    """
+    results = search_ecoalim(matiere, pays_production, pays_transformation)
+    if results.empty:
+        return None
+    # Prendre la première correspondance (ou la plus défavorable si demandé)
+    row = results.iloc[0]
+    val = row.get(config.ECOALIM_COL_CLIMATE)
+    if pd.isna(val):
+        return None
+    nom = row.get(config.ECOALIM_COL_NOM, matiere)
+    return (float(val), str(nom), "ECOALIM")
+
+
+def get_ecoalim_worst_value(matiere: str) -> Optional[Tuple[float, str, str]]:
+    """Retourne la valeur la plus défavorable (max) pour cette matière dans EcoALIM."""
+    results = search_ecoalim(matiere)
+    if results.empty:
+        return None
+    climate_col = config.ECOALIM_COL_CLIMATE
+    results_valid = results.dropna(subset=[climate_col])
+    if results_valid.empty:
+        return None
+    idx = results_valid[climate_col].idxmax()
+    row = results_valid.loc[idx]
+    return (float(row[climate_col]), str(row[config.ECOALIM_COL_NOM]), "ECOALIM (valeur la plus défavorable)")
+
+
+# ============================================================================
+# GFLI
+# ============================================================================
+
+@lru_cache(maxsize=1)
+def load_gfli() -> pd.DataFrame:
+    """Charge la base GFLI (Economic allocation EF3.1)."""
+    df = pd.read_excel(
+        config.GFLI_PATH,
+        sheet_name=config.GFLI_SHEET,
+        header=0,
+    )
+    df = df.dropna(subset=[config.GFLI_COL_PRODUCT]).reset_index(drop=True)
+    return df
+
+
+def _extract_gfli_country(product_name: str) -> Optional[str]:
+    """Extrait le code pays ISO d'un nom de produit GFLI (ex: '.../FR Economic S' -> 'FR')."""
+    m = re.search(r"/([A-Z]{2,3})\s+Economic\s+S", product_name)
+    return m.group(1) if m else None
+
+
+def _extract_gfli_base_name(product_name: str) -> str:
+    """Extrait le nom de base du produit GFLI (sans le code pays)."""
+    m = re.match(r"(.+)/[A-Z]{2,3}\s+Economic\s+S", product_name)
+    return m.group(1).strip() if m else product_name.strip()
+
+
+def search_gfli(
+    matiere: str,
+    country_iso: Optional[str] = None,
+) -> pd.DataFrame:
+    """
+    Recherche dans GFLI par nom de matière (en anglais) et optionnellement par pays ISO.
+    Uses word-boundary matching for better precision.
+    """
+    df = load_gfli()
+    matiere_norm = _normalize_for_search(matiere)
+
+    prod_col = config.GFLI_COL_PRODUCT
+    df_norms = df[prod_col].apply(lambda x: _normalize_for_search(str(x)) if pd.notna(x) else "")
+
+    # Strategy 1: starts-with
+    mask = df_norms.str.startswith(matiere_norm, na=False)
+
+    # Strategy 2: word-boundary match
+    if not mask.any():
+        pattern_word = r'\b' + re.escape(matiere_norm) + r'\b'
+        mask = df_norms.str.contains(pattern_word, na=False, regex=True)
+
+    # Strategy 3: token-subset match (souple)
+    if not mask.any():
+        tokens = _tokens_for_search(matiere_norm)
+        if tokens:
+            mask = df_norms.apply(lambda x: all(t in _tokens_for_search(x) for t in tokens))
+
+    # Strategy 4: contains
+    if not mask.any():
+        mask = df_norms.str.contains(re.escape(matiere_norm), na=False)
+
+    if country_iso:
+        country_upper = country_iso.upper().strip()
+        mask_country = df[prod_col].str.contains(
+            rf"/{re.escape(country_upper)}\s+Economic\s+S", na=False, regex=True
+        )
+        combined = mask & mask_country
+        if combined.any():
+            mask = combined
+
+    return df[mask].copy()
+
+
+def get_gfli_climate_value(
+    matiere: str,
+    country_iso: Optional[str] = None,
+) -> Optional[Tuple[float, str, str]]:
+    """
+    Retourne (valeur_kg_co2_eq_par_tonne, nom_produit, source_info) ou None.
+    Unité GFLI : kg CO2 eq / tonne de produit.
+    """
+    results = search_gfli(matiere, country_iso)
+    if results.empty:
+        return None
+    row = results.iloc[0]
+    val = row.get(config.GFLI_COL_CLIMATE)
+    if pd.isna(val):
+        return None
+    nom = row.get(config.GFLI_COL_PRODUCT, matiere)
+    return (float(val), str(nom), "GFLI")
+
+
+def get_gfli_worst_value(matiere: str) -> Optional[Tuple[float, str, str]]:
+    """Retourne la valeur la plus défavorable (max) pour cette matière dans GFLI."""
+    results = search_gfli(matiere)
+    if results.empty:
+        return None
+    climate_col = config.GFLI_COL_CLIMATE
+    results_valid = results.dropna(subset=[climate_col])
+    if results_valid.empty:
+        return None
+    idx = results_valid[climate_col].idxmax()
+    row = results_valid.loc[idx]
+    return (float(row[climate_col]), str(row[config.GFLI_COL_PRODUCT]), "GFLI (valeur la plus défavorable)")
+
+
+def get_gfli_rer_value(matiere: str) -> Optional[Tuple[float, str, str]]:
+    """Retourne la valeur Mix Européen (RER) dans GFLI."""
+    return get_gfli_climate_value(matiere, "RER")
+
+
+def get_gfli_glo_value(matiere: str) -> Optional[Tuple[float, str, str]]:
+    """Retourne la valeur Mix Monde (GLO) dans GFLI."""
+    return get_gfli_climate_value(matiere, "GLO")
+
+
+# ============================================================================
+# GFLI - Listes utilitaires
+# ============================================================================
+
+def get_gfli_base_products() -> List[str]:
+    """Retourne la liste des noms de base de produits uniques dans GFLI."""
+    df = load_gfli()
+    products = df[config.GFLI_COL_PRODUCT].dropna().unique()
+    base_names = set()
+    for p in products:
+        base_names.add(_extract_gfli_base_name(str(p)))
+    return sorted(base_names)
+
+
+def get_ecoalim_matieres() -> List[str]:
+    """Retourne la liste des matières premières uniques dans EcoALIM."""
+    df = load_ecoalim()
+    return sorted(df[config.ECOALIM_COL_NOM].dropna().unique().tolist())
+
+
+# ============================================================================
+# Fonctions multi-candidats (pour affichage comparatif)
+# ============================================================================
+
+def get_top_ecoalim_candidates(
+    matiere: str,
+    pays_production: Optional[str] = None,
+    pays_transformation: Optional[str] = None,
+    top_n: Optional[int] = 8,
+) -> List[Dict]:
+    """
+    Retourne les top N correspondances EcoALIM triées par pertinence,
+    chacune avec nom + valeur impact.
+    """
+    results = search_ecoalim(matiere, pays_production, pays_transformation)
+    if results.empty:
+        return []
+    candidates = []
+    rows = results if top_n is None else results.head(top_n)
+    for _, row in rows.iterrows():
+        val = row.get(config.ECOALIM_COL_CLIMATE)
+        if pd.notna(val):
+            candidates.append({
+                "nom": str(row[config.ECOALIM_COL_NOM]),
+                "impact": float(val),
+                "unite": "kg CO2 eq / kg",
+                "source": "ECOALIM",
+            })
+    return candidates
+
+
+def get_top_gfli_candidates(
+    matiere: str,
+    country_iso: Optional[str] = None,
+    top_n: Optional[int] = 8,
+) -> List[Dict]:
+    """
+    Retourne les top N correspondances GFLI triées par pertinence,
+    chacune avec nom + valeur impact.
+    """
+    results = search_gfli(matiere, country_iso)
+    if results.empty:
+        return []
+    candidates = []
+    rows = results if top_n is None else results.head(top_n)
+    for _, row in rows.iterrows():
+        val = row.get(config.GFLI_COL_CLIMATE)
+        if pd.notna(val):
+            candidates.append({
+                "nom": str(row[config.GFLI_COL_PRODUCT]),
+                "impact": float(val),
+                "unite": "kg CO2 eq / tonne",
+                "source": "GFLI",
+            })
+    return candidates
+
+
+# ============================================================================
+# PDF CIR - Catalogue des Matières Premières
+# ============================================================================
+
+@lru_cache(maxsize=1)
+def load_pdf_text() -> str:
+    """Charge et retourne le texte complet du PDF CIR."""
+    full_text = []
+    with pdfplumber.open(config.PDF_CIR_PATH) as pdf:
+        for page in pdf.pages:
+            text = page.extract_text()
+            if text:
+                full_text.append(text)
+    return "\n\n".join(full_text)
+
+
+def get_pdf_excerpt(max_chars: int = 15000) -> str:
+    """Retourne un extrait du PDF CIR (tronqué si nécessaire) pour envoi au LLM."""
+    text = load_pdf_text()
+    if len(text) > max_chars:
+        return text[:max_chars] + "\n... [texte tronqué]"
+    return text
+
+
+# ============================================================================
+# Logigramme
+# ============================================================================
+
+@lru_cache(maxsize=1)
+def load_logigramme() -> dict:
+    """Charge le logigramme JSON."""
+    with open(config.LOGIGRAMME_PATH, "r", encoding="utf-8") as f:
+        return json.load(f)

flowchart_engine.py

@@ -0,0 +1,1286 @@
+"""
+flowchart_engine.py - Moteur du logigramme d'aide à la détermination de l'impact carbone.
+
+Suit le logigramme JSON pour déterminer quelle valeur d'impact carbone utiliser
+en fonction de la provenance, du niveau de transformation, et des données disponibles.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Tuple
+
+import config
+import data_loader
+import llm_service
+
+
+@dataclass
+class StepLog:
+    """Un pas dans le parcours du logigramme."""
+    node_id: str
+    question: Optional[str]
+    answer: Optional[str]
+    action: Optional[str] = None
+    result: Optional[str] = None
+
+
+@dataclass
+class CarbonResult:
+    """Résultat complet de l'évaluation carbone d'une matière première."""
+    matiere_premiere: str
+    pays_production: Optional[str]
+    pays_transformation: Optional[str]
+    classification: str  # "brut" | "transforme"
+    classification_justification: str
+    
+    # Valeur finale
+    impact_kg_co2_eq: Optional[float] = None
+    impact_tonne_co2_eq: Optional[float] = None  # conversion en tonnes
+    unite_source: str = ""  # "kg CO2 eq / kg" ou "kg CO2 eq / tonne"
+    
+    # Traçabilité
+    source_db: str = ""  # "ECOALIM" | "GFLI"
+    intrant_utilise: str = ""  # nom exact dans la BDD
+    match_exact: bool = True
+    justification_alternative: Optional[str] = None
+    
+    # Parcours de logique
+    parcours: List[StepLog] = field(default_factory=list)
+    node_resultat: str = ""  # node_id du résultat
+    actions_appliquees: List[str] = field(default_factory=list)
+    
+    # Candidats alternatifs (pour affichage comparatif quand match non exact)
+    candidats_alternatifs: List[dict] = field(default_factory=list)
+    candidat_recommande: Optional[str] = None
+    candidats_reflexion: Optional[str] = None
+    
+    # 4 propositions d'alternatives (itinerary, locality, form, combined)
+    alternatives_itinerary: Optional[dict] = None
+    alternatives_locality: Optional[dict] = None
+    alternatives_form: Optional[dict] = None
+    alternatives_combined: Optional[dict] = None
+    
+    erreur: Optional[str] = None
+
+
+def _is_france(pays: Optional[str]) -> bool:
+    """Vérifie si le pays est la France."""
+    if not pays:
+        return False
+    return pays.lower().strip() in ("france", "fr")
+
+
+def _is_european(pays: Optional[str]) -> bool:
+    """Vérifie si le pays est européen."""
+    if not pays:
+        return False
+    pays_low = pays.lower().strip()
+    if pays_low in config.EUROPEAN_COUNTRIES_FR:
+        return True
+    pays_iso = config.PAYS_FR_TO_ISO.get(pays_low, "").upper()
+    return pays_iso in config.EUROPEAN_COUNTRIES_ISO
+
+
+def _get_country_iso(pays: Optional[str]) -> Optional[str]:
+    """Convertit un nom de pays FR en code ISO."""
+    if not pays:
+        return None
+    return config.PAYS_FR_TO_ISO.get(pays.lower().strip())
+
+
+def _is_name_match(matiere: str, intrant_name: str) -> bool:
+    """
+    Vérifie si le nom de la matière est une correspondance réelle (mot entier)
+    dans le nom de l'intrant, et non un simple sous-chaîne accidentelle.
+    Délègue à data_loader.is_name_match.
+    """
+    return data_loader.is_name_match(matiere, intrant_name)
+
+
+# ============================================================================
+# Fonctions de résolution par node de résultat
+# ============================================================================
+
+def _resolve_node_4(matiere: str, result: CarbonResult) -> CarbonResult:
+    """
+    Node 4 : Provenance inconnue + intrant brut.
+    1. Valeur la plus défavorable dans GFLI
+    2. Sinon la plus défavorable dans ECOALIM
+    3. Sinon valeur GFLI de l'intrant au schéma cultural le plus proche (LLM)
+    """
+    # Étape 1 : GFLI worst
+    result.actions_appliquees.append("1. Recherche de la valeur la plus défavorable dans GFLI")
+    gfli_worst = data_loader.get_gfli_worst_value(matiere)
+
+    # Rejeter les faux positifs (ex : "blé" → "blend")
+    if gfli_worst and not _is_name_match(matiere, gfli_worst[1]):
+        result.actions_appliquees.append(f"   ⚠ Faux positif rejeté : {gfli_worst[1]}")
+        gfli_worst = None
+
+    llm_justification = None
+    llm_match_exact = None
+    if not gfli_worst:
+        gfli_smart = llm_service.smart_search_gfli(matiere)
+        if gfli_smart and "valeur_kg_co2_eq_par_tonne" in gfli_smart:
+            llm_match_exact = gfli_smart.get("match_exact", False)
+            llm_justification = gfli_smart.get("justification")
+            base_name = gfli_smart["nom_intrant"].split(",")[0].split("/")[0].strip()
+            gfli_worst = data_loader.get_gfli_worst_value(base_name)
+            if not gfli_worst:
+                # Utiliser directement la valeur du LLM
+                gfli_worst = (
+                    gfli_smart["valeur_kg_co2_eq_par_tonne"],
+                    gfli_smart["nom_intrant"],
+                    gfli_smart.get("source", "GFLI"),
+                )
+
+    if gfli_worst:
+        val, nom, src = gfli_worst
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = src
+        result.intrant_utilise = nom
+        # Déterminer si le match est exact
+        if llm_match_exact is not None:
+            result.match_exact = llm_match_exact
+        else:
+            result.match_exact = _is_name_match(matiere, nom)
+        if llm_justification:
+            result.justification_alternative = llm_justification
+        result.actions_appliquees.append(f"   → Trouvé dans GFLI : {nom} = {val:.2f} kg CO2 eq/t")
+        return result
+
+    # Étape 2 : ECOALIM worst
+    result.actions_appliquees.append("2. Recherche de la valeur la plus défavorable dans ECOALIM")
+    eco_worst = data_loader.get_ecoalim_worst_value(matiere)
+
+    # Rejeter les faux positifs
+    if eco_worst and not _is_name_match(matiere, eco_worst[1]):
+        result.actions_appliquees.append(f"   ⚠ Faux positif rejeté : {eco_worst[1]}")
+        eco_worst = None
+
+    llm_justification_eco = None
+    llm_match_exact_eco = None
+    if not eco_worst:
+        eco_smart = llm_service.smart_search_ecoalim(matiere)
+        if eco_smart:
+            llm_match_exact_eco = eco_smart.get("match_exact", False)
+            llm_justification_eco = eco_smart.get("justification")
+            eco_worst = data_loader.get_ecoalim_worst_value(
+                eco_smart["nom_intrant"].split(",")[0].strip()
+            )
+            if not eco_worst:
+                eco_worst = (
+                    eco_smart["valeur_kg_co2_eq"],
+                    eco_smart["nom_intrant"],
+                    eco_smart.get("source", "ECOALIM"),
+                )
+
+    if eco_worst:
+        val, nom, src = eco_worst
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = src
+        result.intrant_utilise = nom
+        if llm_match_exact_eco is not None:
+            result.match_exact = llm_match_exact_eco
+        else:
+            result.match_exact = _is_name_match(matiere, nom)
+        if llm_justification_eco:
+            result.justification_alternative = llm_justification_eco
+        result.actions_appliquees.append(f"   → Trouvé dans ECOALIM : {nom} = {val:.4f} kg CO2 eq/kg")
+        return result
+
+    # Étape 3 : LLM pour trouver le schéma cultural le plus proche
+    result.actions_appliquees.append("3. Recherche via LLM de l'intrant au schéma cultural le plus proche (GFLI)")
+    gfli_smart = llm_service.smart_search_gfli(matiere)
+    if gfli_smart and "valeur_kg_co2_eq_par_tonne" in gfli_smart:
+        val = gfli_smart["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_smart["source"]
+        result.intrant_utilise = gfli_smart["nom_intrant"]
+        result.match_exact = gfli_smart.get("match_exact", False)
+        result.justification_alternative = gfli_smart.get("justification")
+        result.actions_appliquees.append(f"   → Via LLM : {gfli_smart['nom_intrant']} = {val:.2f} kg CO2 eq/t")
+        return result
+
+    # Étape 4 : Fallback - Proposer des matières alternatives
+    result.actions_appliquees.append("4. Fallback - Recherche via LLM de 4 alternatives")
+    alternatives = llm_service.find_alternative_materials(matiere, db_name="GFLI")
+    
+    if alternatives:
+        # Stocker les 4 alternatives dans CarbonResult
+        if alternatives.get("itinerary"):
+            alt = alternatives["itinerary"]
+            result.alternatives_itinerary = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("locality"):
+            alt = alternatives["locality"]
+            result.alternatives_locality = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("form"):
+            alt = alternatives["form"]
+            result.alternatives_form = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("combined"):
+            alt = alternatives["combined"]
+            result.alternatives_combined = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+            # Utiliser la combined comme valeur principale
+            val = alt["impact"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val / 1000.0
+            result.unite_source = "kg CO2 eq / tonne de produit"
+            result.source_db = alt["source"]
+            result.intrant_utilise = alt["name"]
+            result.match_exact = False
+            result.justification_alternative = alt["reasoning"]
+            result.actions_appliquees.append(f"   → Matière proposée (combo) : {alt['name']} = {val:.2f} kg CO2 eq/t")
+            return result
+
+    result.erreur = f"Aucune valeur trouvée pour '{matiere}' dans GFLI ni ECOALIM."
+    return result
+
+
+def _resolve_node_5(matiere: str, result: CarbonResult) -> CarbonResult:
+    """
+    Node 5 : Provenance inconnue + intrant transformé.
+    Mêmes étapes que node_4 mais pour un intrant transformé.
+    """
+    # Étape 1 : GFLI worst
+    result.actions_appliquees.append("1. Recherche de la valeur la plus défavorable pour l'intrant transformé dans GFLI")
+    gfli_worst = data_loader.get_gfli_worst_value(matiere)
+
+    # Rejeter les faux positifs
+    if gfli_worst and not _is_name_match(matiere, gfli_worst[1]):
+        result.actions_appliquees.append(f"   ⚠ Faux positif rejeté : {gfli_worst[1]}")
+        gfli_worst = None
+
+    llm_justification = None
+    llm_match_exact = None
+    if not gfli_worst:
+        gfli_smart = llm_service.smart_search_gfli(matiere)
+        if gfli_smart and "valeur_kg_co2_eq_par_tonne" in gfli_smart:
+            llm_match_exact = gfli_smart.get("match_exact", False)
+            llm_justification = gfli_smart.get("justification")
+            base_name = gfli_smart["nom_intrant"].split(",")[0].split("/")[0].strip()
+            gfli_worst = data_loader.get_gfli_worst_value(base_name)
+            if not gfli_worst:
+                gfli_worst = (
+                    gfli_smart["valeur_kg_co2_eq_par_tonne"],
+                    gfli_smart["nom_intrant"],
+                    gfli_smart.get("source", "GFLI"),
+                )
+
+    if gfli_worst:
+        val, nom, src = gfli_worst
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = src
+        result.intrant_utilise = nom
+        if llm_match_exact is not None:
+            result.match_exact = llm_match_exact
+        else:
+            result.match_exact = _is_name_match(matiere, nom)
+        if llm_justification:
+            result.justification_alternative = llm_justification
+        result.actions_appliquees.append(f"   → Trouvé dans GFLI : {nom} = {val:.2f} kg CO2 eq/t")
+        return result
+
+    # Étape 2 : ECOALIM worst
+    result.actions_appliquees.append("2. Recherche de la valeur la plus défavorable dans ECOALIM")
+    eco_worst = data_loader.get_ecoalim_worst_value(matiere)
+
+    if eco_worst and not _is_name_match(matiere, eco_worst[1]):
+        result.actions_appliquees.append(f"   ⚠ Faux positif rejeté : {eco_worst[1]}")
+        eco_worst = None
+
+    llm_justification_eco = None
+    llm_match_exact_eco = None
+    if not eco_worst:
+        eco_smart = llm_service.smart_search_ecoalim(matiere)
+        if eco_smart:
+            llm_match_exact_eco = eco_smart.get("match_exact", False)
+            llm_justification_eco = eco_smart.get("justification")
+            eco_worst = data_loader.get_ecoalim_worst_value(
+                eco_smart["nom_intrant"].split(",")[0].strip()
+            )
+            if not eco_worst:
+                eco_worst = (
+                    eco_smart["valeur_kg_co2_eq"],
+                    eco_smart["nom_intrant"],
+                    eco_smart.get("source", "ECOALIM"),
+                )
+
+    if eco_worst:
+        val, nom, src = eco_worst
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = src
+        result.intrant_utilise = nom
+        if llm_match_exact_eco is not None:
+            result.match_exact = llm_match_exact_eco
+        else:
+            result.match_exact = _is_name_match(matiere, nom)
+        if llm_justification_eco:
+            result.justification_alternative = llm_justification_eco
+        result.actions_appliquees.append(f"   → Trouvé dans ECOALIM : {nom} = {val:.4f} kg CO2 eq/kg")
+        return result
+
+    # Étape 3 : LLM
+    result.actions_appliquees.append("3. Recherche via LLM de l'intrant transformé au process le plus proche (GFLI)")
+    gfli_smart = llm_service.smart_search_gfli(matiere)
+    if gfli_smart and "valeur_kg_co2_eq_par_tonne" in gfli_smart:
+        val = gfli_smart["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_smart["source"]
+        result.intrant_utilise = gfli_smart["nom_intrant"]
+        result.match_exact = gfli_smart.get("match_exact", False)
+        result.justification_alternative = gfli_smart.get("justification")
+        result.actions_appliquees.append(f"   → Via LLM : {gfli_smart['nom_intrant']}")
+        return result
+
+    # Étape 4 : Fallback - Proposer des matières alternatives
+    result.actions_appliquees.append("4. Fallback - Recherche via LLM de 4 alternatives (transformée)")
+    alternatives = llm_service.find_alternative_materials(matiere, db_name="GFLI")
+    
+    if alternatives:
+        # Stocker les 4 alternatives
+        if alternatives.get("itinerary"):
+            alt = alternatives["itinerary"]
+            result.alternatives_itinerary = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("locality"):
+            alt = alternatives["locality"]
+            result.alternatives_locality = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("form"):
+            alt = alternatives["form"]
+            result.alternatives_form = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("combined"):
+            alt = alternatives["combined"]
+            result.alternatives_combined = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+            # Utiliser la combined comme valeur principale
+            val = alt["impact"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val / 1000.0
+            result.unite_source = "kg CO2 eq / tonne de produit"
+            result.source_db = alt["source"]
+            result.intrant_utilise = alt["name"]
+            result.match_exact = False
+            result.justification_alternative = alt["reasoning"]
+            result.actions_appliquees.append(f"   → Matière proposée (combo) : {alt['name']} = {val:.2f} kg CO2 eq/t")
+            return result
+
+    result.erreur = f"Aucune valeur trouvée pour '{matiere}' (transformé, provenance inconnue)."
+    return result
+
+
+def _resolve_node_8(matiere: str, result: CarbonResult) -> CarbonResult:
+    """
+    Node 8 : Provenance connue + brut + cultivé en France.
+    1. EcoALIM
+    2. GFLI
+    3. Intrant à la pratique culturale la plus proche dans EcoALIM (LLM)
+    """
+    result.actions_appliquees.append("1. Recherche dans ECOALIM pour la France")
+    eco_result = llm_service.smart_search_ecoalim(matiere, pays_production="France")
+    if eco_result:
+        val = eco_result["valeur_kg_co2_eq"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = eco_result["source"]
+        result.intrant_utilise = eco_result["nom_intrant"]
+        result.match_exact = eco_result["match_exact"]
+        result.justification_alternative = eco_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans ECOALIM : {eco_result['nom_intrant']} = {val:.4f} kg CO2 eq/kg")
+        return result
+
+    result.actions_appliquees.append("2. Recherche dans GFLI pour FR")
+    gfli_result = llm_service.smart_search_gfli(matiere, country_iso="FR")
+    if gfli_result:
+        val = gfli_result["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_result["source"]
+        result.intrant_utilise = gfli_result["nom_intrant"]
+        result.match_exact = gfli_result["match_exact"]
+        result.justification_alternative = gfli_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans GFLI : {gfli_result['nom_intrant']}")
+        return result
+
+    result.actions_appliquees.append("3. Recherche via LLM de la pratique culturale la plus proche dans ECOALIM")
+    eco_smart = llm_service.smart_search_ecoalim(matiere)
+    if eco_smart:
+        val = eco_smart["valeur_kg_co2_eq"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = eco_smart["source"]
+        result.intrant_utilise = eco_smart["nom_intrant"]
+        result.match_exact = False
+        result.justification_alternative = eco_smart.get("justification")
+        result.actions_appliquees.append(f"   → Via LLM : {eco_smart['nom_intrant']}")
+        return result
+
+    # Étape 4 : Fallback - Proposer des matières alternatives
+    result.actions_appliquees.append("4. Fallback - Recherche via LLM de 4 alternatives (France)")
+    alternatives = llm_service.find_alternative_materials(matiere, db_name="GFLI", country_hint="France")
+    
+    if alternatives:
+        # Stocker les 4 alternatives dans CarbonResult
+        if alternatives.get("itinerary"):
+            alt = alternatives["itinerary"]
+            result.alternatives_itinerary = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("locality"):
+            alt = alternatives["locality"]
+            result.alternatives_locality = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("form"):
+            alt = alternatives["form"]
+            result.alternatives_form = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("combined"):
+            alt = alternatives["combined"]
+            result.alternatives_combined = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+            # Utiliser la combined comme valeur principale
+            val = alt["impact"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val / 1000.0
+            result.unite_source = "kg CO2 eq / tonne de produit"
+            result.source_db = alt["source"]
+            result.intrant_utilise = alt["name"]
+            result.match_exact = False
+            result.justification_alternative = alt["reasoning"]
+            result.actions_appliquees.append(f"   → Matière proposée (combo) : {alt['name']} = {val:.2f} kg CO2 eq/t")
+            return result
+
+    result.erreur = f"Aucune valeur trouvée pour '{matiere}' (brut, France)."
+    return result
+
+
+def _resolve_node_9(matiere: str, pays_production: str, result: CarbonResult) -> CarbonResult:
+    """
+    Node 9 : Provenance connue + brut + cultivé hors France.
+    1. GFLI du pays correspondant
+    2. RER (Europe) ou GLO (autre continent)
+    3. EcoALIM
+    """
+    country_iso = _get_country_iso(pays_production)
+
+    result.actions_appliquees.append(f"1. Recherche dans GFLI pour le pays {pays_production} (ISO: {country_iso})")
+    gfli_result = llm_service.smart_search_gfli(matiere, country_iso=country_iso)
+    if gfli_result:
+        val = gfli_result["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_result["source"]
+        result.intrant_utilise = gfli_result["nom_intrant"]
+        result.match_exact = gfli_result["match_exact"]
+        result.justification_alternative = gfli_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans GFLI : {gfli_result['nom_intrant']}")
+        return result
+
+    # Étape 2 : RER ou GLO
+    is_eu = _is_european(pays_production)
+    if is_eu:
+        result.actions_appliquees.append("2. Pays européen → Recherche Mix Européen (RER) dans GFLI")
+        rer = llm_service.smart_search_gfli(matiere, country_iso="RER")
+        if rer:
+            val = rer["valeur_kg_co2_eq_par_tonne"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val / 1000.0
+            result.unite_source = "kg CO2 eq / tonne de produit"
+            result.source_db = rer["source"] + " (Mix Européen RER)"
+            result.intrant_utilise = rer["nom_intrant"]
+            result.match_exact = rer["match_exact"]
+            result.justification_alternative = rer.get("justification")
+            result.actions_appliquees.append(f"   → Trouvé RER : {rer['nom_intrant']}")
+            return result
+    else:
+        result.actions_appliquees.append("2. Pays hors Europe → Recherche Mix Monde (GLO) dans GFLI")
+        glo = llm_service.smart_search_gfli(matiere, country_iso="GLO")
+        if glo:
+            val = glo["valeur_kg_co2_eq_par_tonne"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val / 1000.0
+            result.unite_source = "kg CO2 eq / tonne de produit"
+            result.source_db = glo["source"] + " (Mix Monde GLO)"
+            result.intrant_utilise = glo["nom_intrant"]
+            result.match_exact = glo["match_exact"]
+            result.justification_alternative = glo.get("justification")
+            result.actions_appliquees.append(f"   → Trouvé GLO : {glo['nom_intrant']}")
+            return result
+
+    result.actions_appliquees.append("3. Recherche dans ECOALIM")
+    eco_result = llm_service.smart_search_ecoalim(matiere, pays_production=pays_production)
+    if eco_result:
+        val = eco_result["valeur_kg_co2_eq"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = eco_result["source"]
+        result.intrant_utilise = eco_result["nom_intrant"]
+        result.match_exact = eco_result["match_exact"]
+        result.justification_alternative = eco_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans ECOALIM : {eco_result['nom_intrant']}")
+        return result
+
+    # Étape 4 : Fallback - Proposer des matières alternatives
+    result.actions_appliquees.append(f"4. Fallback - Recherche via LLM de 4 alternatives ({pays_production})")
+    alternatives = llm_service.find_alternative_materials(matiere, db_name="GFLI", country_hint=pays_production)
+    
+    if alternatives:
+        # Stocker les 4 alternatives dans CarbonResult
+        if alternatives.get("itinerary"):
+            alt = alternatives["itinerary"]
+            result.alternatives_itinerary = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("locality"):
+            alt = alternatives["locality"]
+            result.alternatives_locality = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("form"):
+            alt = alternatives["form"]
+            result.alternatives_form = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("combined"):
+            alt = alternatives["combined"]
+            result.alternatives_combined = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+            # Utiliser la combined comme valeur principale
+            val = alt["impact"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val / 1000.0
+            result.unite_source = "kg CO2 eq / tonne de produit"
+            result.source_db = alt["source"]
+            result.intrant_utilise = alt["name"]
+            result.match_exact = False
+            result.justification_alternative = alt["reasoning"]
+            result.actions_appliquees.append(f"   → Matière proposée (combo) : {alt['name']} = {val:.2f} kg CO2 eq/t")
+            return result
+
+    result.erreur = f"Aucune valeur trouvée pour '{matiere}' (brut, {pays_production})."
+    return result
+
+
+def _resolve_node_10(matiere: str, result: CarbonResult) -> CarbonResult:
+    """
+    Node 10 : Provenance connue + transformé + France/France.
+    1. EcoALIM pour l'intrant transformé
+    2. A/ impact process connu : brut EcoALIM + process / B/ sinon GFLI
+    3. Intrant au process le plus proche dans EcoALIM (LLM)
+    """
+    result.actions_appliquees.append("1. Recherche dans ECOALIM (transformé France/France)")
+    eco_result = llm_service.smart_search_ecoalim(matiere, pays_production="France", pays_transformation="France")
+    if eco_result:
+        val = eco_result["valeur_kg_co2_eq"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = eco_result["source"]
+        result.intrant_utilise = eco_result["nom_intrant"]
+        result.match_exact = eco_result["match_exact"]
+        result.justification_alternative = eco_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans ECOALIM : {eco_result['nom_intrant']} = {val:.4f}")
+        return result
+
+    # Étape 2 : GFLI France
+    result.actions_appliquees.append("2. Impact process non connu → Recherche dans GFLI (FR)")
+    gfli_result = llm_service.smart_search_gfli(matiere, country_iso="FR")
+    if gfli_result:
+        val = gfli_result["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_result["source"]
+        result.intrant_utilise = gfli_result["nom_intrant"]
+        result.match_exact = gfli_result["match_exact"]
+        result.justification_alternative = gfli_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans GFLI : {gfli_result['nom_intrant']}")
+        return result
+
+    # Étape 3 : LLM process le plus proche
+    result.actions_appliquees.append("3. Recherche via LLM du process le plus proche dans ECOALIM")
+    eco_smart = llm_service.smart_search_ecoalim(matiere)
+    if eco_smart:
+        val = eco_smart["valeur_kg_co2_eq"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = eco_smart["source"]
+        result.intrant_utilise = eco_smart["nom_intrant"]
+        result.match_exact = False
+        result.justification_alternative = eco_smart.get("justification")
+        result.actions_appliquees.append(f"   → Via LLM : {eco_smart['nom_intrant']}")
+        return result
+
+    # Étape 4 : Fallback - Proposer des matières alternatives
+    result.actions_appliquees.append("4. Fallback - Recherche via LLM de 4 alternatives (France)")
+    alternatives = llm_service.find_alternative_materials(matiere, db_name="GFLI", country_hint="France")
+    
+    if alternatives:
+        # Stocker les 4 alternatives dans CarbonResult
+        if alternatives.get("itinerary"):
+            alt = alternatives["itinerary"]
+            result.alternatives_itinerary = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("locality"):
+            alt = alternatives["locality"]
+            result.alternatives_locality = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("form"):
+            alt = alternatives["form"]
+            result.alternatives_form = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("combined"):
+            alt = alternatives["combined"]
+            result.alternatives_combined = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+            # Utiliser la combined comme valeur principale
+            val = alt["impact"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val
+            result.unite_source = "kg CO2 eq / kg de produit"
+            result.source_db = alt["source"]
+            result.intrant_utilise = alt["name"]
+            result.match_exact = False
+            result.justification_alternative = alt["reasoning"]
+            result.actions_appliquees.append(f"   → Matière proposée (combo) : {alt['name']} = {val:.4f} kg CO2 eq/kg")
+            return result
+
+    result.erreur = f"Aucune valeur trouvée pour '{matiere}' (transformé, France/France)."
+    return result
+
+
+def _resolve_node_11(matiere: str, result: CarbonResult) -> CarbonResult:
+    """
+    Node 11 : Transformé en France, MP brute non FR ou inconnue.
+    1. GFLI France
+    2. A/ process connu → brut GFLI + process / B/ sinon RER
+    3. EcoALIM
+    4. Pratique culturale la plus proche GFLI (LLM)
+    """
+    result.actions_appliquees.append("1. Recherche dans GFLI (France)")
+    gfli_result = llm_service.smart_search_gfli(matiere, country_iso="FR")
+    if gfli_result:
+        val = gfli_result["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_result["source"]
+        result.intrant_utilise = gfli_result["nom_intrant"]
+        result.match_exact = gfli_result["match_exact"]
+        result.justification_alternative = gfli_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans GFLI : {gfli_result['nom_intrant']}")
+        return result
+
+    # Étape 2 : RER
+    result.actions_appliquees.append("2. Impact process non connu → Recherche Mix Européen (RER) dans GFLI")
+    rer = llm_service.smart_search_gfli(matiere, country_iso="RER")
+    if rer:
+        val = rer["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = rer["source"] + " (Mix Européen RER)"
+        result.intrant_utilise = rer["nom_intrant"]
+        result.match_exact = rer["match_exact"]
+        result.justification_alternative = rer.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé RER : {rer['nom_intrant']}")
+        return result
+
+    # Étape 3 : EcoALIM
+    result.actions_appliquees.append("3. Recherche dans ECOALIM")
+    eco_result = llm_service.smart_search_ecoalim(matiere)
+    if eco_result:
+        val = eco_result["valeur_kg_co2_eq"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = eco_result["source"]
+        result.intrant_utilise = eco_result["nom_intrant"]
+        result.match_exact = eco_result["match_exact"]
+        result.justification_alternative = eco_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans ECOALIM : {eco_result['nom_intrant']}")
+        return result
+
+    # Étape 4 : LLM
+    result.actions_appliquees.append("4. Recherche via LLM de la pratique culturale la plus proche (GFLI)")
+    gfli_smart = llm_service.smart_search_gfli(matiere)
+    if gfli_smart:
+        val = gfli_smart["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_smart["source"]
+        result.intrant_utilise = gfli_smart["nom_intrant"]
+        result.match_exact = False
+        result.justification_alternative = gfli_smart.get("justification")
+        result.actions_appliquees.append(f"   → Via LLM : {gfli_smart['nom_intrant']}")
+        return result
+
+    # Étape 5 : Fallback - Proposer des matières alternatives
+    result.actions_appliquees.append("5. Fallback - Recherche via LLM de 4 alternatives (France)")
+    alternatives = llm_service.find_alternative_materials(matiere, db_name="GFLI", country_hint="France")
+    
+    if alternatives:
+        # Stocker les 4 alternatives dans CarbonResult
+        if alternatives.get("itinerary"):
+            alt = alternatives["itinerary"]
+            result.alternatives_itinerary = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("locality"):
+            alt = alternatives["locality"]
+            result.alternatives_locality = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("form"):
+            alt = alternatives["form"]
+            result.alternatives_form = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("combined"):
+            alt = alternatives["combined"]
+            result.alternatives_combined = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+            # Utiliser la combined comme valeur principale
+            val = alt["impact"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val / 1000.0
+            result.unite_source = "kg CO2 eq / tonne de produit"
+            result.source_db = alt["source"]
+            result.intrant_utilise = alt["name"]
+            result.match_exact = False
+            result.justification_alternative = alt["reasoning"]
+            result.actions_appliquees.append(f"   → Matière proposée (combo) : {alt['name']} = {val:.2f} kg CO2 eq/t")
+            return result
+
+    result.erreur = f"Aucune valeur trouvée pour '{matiere}' (transformé France, MP brute hors FR)."
+    return result
+
+
+def _resolve_node_12(matiere: str, pays_transformation: str, result: CarbonResult) -> CarbonResult:
+    """
+    Node 12 : Transformé hors France.
+    1. GFLI du pays correspondant
+    2. A/ process connu / B/ sinon RER (Europe) ou GLO (autre)
+    3. EcoALIM
+    4. Pratique culturale la plus proche GFLI (LLM)
+    """
+    country_iso = _get_country_iso(pays_transformation)
+
+    result.actions_appliquees.append(f"1. Recherche dans GFLI pour {pays_transformation} (ISO: {country_iso})")
+    gfli_result = llm_service.smart_search_gfli(matiere, country_iso=country_iso)
+    if gfli_result:
+        val = gfli_result["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_result["source"]
+        result.intrant_utilise = gfli_result["nom_intrant"]
+        result.match_exact = gfli_result["match_exact"]
+        result.justification_alternative = gfli_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans GFLI : {gfli_result['nom_intrant']}")
+        return result
+
+    # Étape 2 : RER ou GLO
+    is_eu = _is_european(pays_transformation)
+    if is_eu:
+        result.actions_appliquees.append("2. Pays européen → Recherche Mix Européen (RER)")
+        fallback = llm_service.smart_search_gfli(matiere, country_iso="RER")
+    else:
+        result.actions_appliquees.append("2. Pays hors Europe → Recherche Mix Monde (GLO)")
+        fallback = llm_service.smart_search_gfli(matiere, country_iso="GLO")
+
+    if fallback:
+        val = fallback["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        mix_type = "RER" if is_eu else "GLO"
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = fallback["source"] + f" (Mix {mix_type})"
+        result.intrant_utilise = fallback["nom_intrant"]
+        result.match_exact = fallback["match_exact"]
+        result.justification_alternative = fallback.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé {mix_type} : {fallback['nom_intrant']}")
+        return result
+
+    # Étape 3 : EcoALIM
+    result.actions_appliquees.append("3. Recherche dans ECOALIM")
+    eco_result = llm_service.smart_search_ecoalim(matiere)
+    if eco_result:
+        val = eco_result["valeur_kg_co2_eq"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / kg de produit"
+        result.source_db = eco_result["source"]
+        result.intrant_utilise = eco_result["nom_intrant"]
+        result.match_exact = eco_result["match_exact"]
+        result.justification_alternative = eco_result.get("justification")
+        result.actions_appliquees.append(f"   → Trouvé dans ECOALIM : {eco_result['nom_intrant']}")
+        return result
+
+    # Étape 4 : LLM
+    result.actions_appliquees.append("4. Recherche via LLM de la pratique culturale la plus proche (GFLI)")
+    gfli_smart = llm_service.smart_search_gfli(matiere)
+    if gfli_smart:
+        val = gfli_smart["valeur_kg_co2_eq_par_tonne"]
+        result.impact_kg_co2_eq = val
+        result.impact_tonne_co2_eq = val / 1000.0
+        result.unite_source = "kg CO2 eq / tonne de produit"
+        result.source_db = gfli_smart["source"]
+        result.intrant_utilise = gfli_smart["nom_intrant"]
+        result.match_exact = False
+        result.justification_alternative = gfli_smart.get("justification")
+        result.actions_appliquees.append(f"   → Via LLM : {gfli_smart['nom_intrant']}")
+        return result
+
+    # Étape 5 : Fallback - Proposer des matières alternatives
+    result.actions_appliquees.append(f"5. Fallback - Recherche via LLM de 4 alternatives ({pays_transformation})")
+    alternatives = llm_service.find_alternative_materials(matiere, db_name="GFLI", country_hint=pays_transformation)
+    
+    if alternatives:
+        # Stocker les 4 alternatives dans CarbonResult
+        if alternatives.get("itinerary"):
+            alt = alternatives["itinerary"]
+            result.alternatives_itinerary = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("locality"):
+            alt = alternatives["locality"]
+            result.alternatives_locality = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("form"):
+            alt = alternatives["form"]
+            result.alternatives_form = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+        if alternatives.get("combined"):
+            alt = alternatives["combined"]
+            result.alternatives_combined = {
+                "name": alt["name"],
+                "impact": alt["impact"],
+                "source": alt["source"],
+                "reasoning": alt["reasoning"],
+            }
+            # Utiliser la combined comme valeur principale
+            val = alt["impact"]
+            result.impact_kg_co2_eq = val
+            result.impact_tonne_co2_eq = val / 1000.0
+            result.unite_source = "kg CO2 eq / tonne de produit"
+            result.source_db = alt["source"]
+            result.intrant_utilise = alt["name"]
+            result.match_exact = False
+            result.justification_alternative = alt["reasoning"]
+            result.actions_appliquees.append(f"   → Matière proposée (combo) : {alt['name']} = {val:.2f} kg CO2 eq/t")
+            return result
+
+    result.erreur = f"Aucune valeur trouvée pour '{matiere}' (transformé hors France)."
+    return result
+
+
+# ============================================================================
+# Moteur principal
+# ============================================================================
+
+def evaluate_carbon_impact(
+    matiere_premiere: str,
+    pays_production: Optional[str] = None,
+    pays_transformation: Optional[str] = None,
+) -> CarbonResult:
+    """
+    Point d'entrée principal : évalue l'impact carbone d'une matière première
+    en suivant le logigramme.
+    
+    Args:
+        matiere_premiere: Nom de la matière première (ex: "BLE", "T.TNSL DEC.", "SOJA")
+        pays_production: Pays de production de la MP brute (ex: "France", "Brésil") ou None si inconnu
+        pays_transformation: Pays de transformation (ex: "France") ou None si pas de transformation
+    
+    Returns:
+        CarbonResult avec toutes les informations
+    """
+    result = CarbonResult(
+        matiere_premiere=matiere_premiere,
+        pays_production=pays_production,
+        pays_transformation=pays_transformation,
+        classification="",
+        classification_justification="",
+    )
+
+    # -----------------------------------------------------------------------
+    # Étape 1 : Classifier brut vs transformé via LLM + PDF CIR
+    # -----------------------------------------------------------------------
+    classification = llm_service.determine_brut_ou_transforme(matiere_premiere)
+    result.classification = classification.get("classification", "brut")
+    result.classification_justification = classification.get("justification", "")
+    is_transformed = result.classification == "transforme"
+
+    result.parcours.append(StepLog(
+        node_id="classification",
+        question="La matière est-elle brute ou transformée ?",
+        answer=f"{'Transformée' if is_transformed else 'Brute'} — {result.classification_justification}",
+    ))
+
+    # -----------------------------------------------------------------------
+    # Étape 2 : Node 1 - Connaît-on la provenance ?
+    # -----------------------------------------------------------------------
+    provenance_connue = bool(pays_production)
+
+    if not provenance_connue:
+        result.parcours.append(StepLog(
+            node_id="node_1",
+            question="Connaissez-vous l'endroit où l'intrant a été cultivé ou produit ?",
+            answer="Non — provenance inconnue",
+        ))
+
+        # Node 2 : brut ou transformé ?
+        if not is_transformed:
+            result.parcours.append(StepLog(
+                node_id="node_2",
+                question="Quel est le niveau de transformation ?",
+                answer="Intrant brut/non transformé",
+            ))
+            result.node_resultat = "node_4"
+            result = _resolve_node_4(matiere_premiere, result)
+        else:
+            result.parcours.append(StepLog(
+                node_id="node_2",
+                question="Quel est le niveau de transformation ?",
+                answer="Coproduit/intrant transformé",
+            ))
+            result.node_resultat = "node_5"
+            result = _resolve_node_5(matiere_premiere, result)
+
+    else:
+        # Provenance connue
+        result.parcours.append(StepLog(
+            node_id="node_1",
+            question="Connaissez-vous l'endroit où l'intrant a été cultivé ou produit ?",
+            answer=f"Oui — Production: {pays_production}" + (f", Transformation: {pays_transformation}" if pays_transformation else ""),
+        ))
+
+        if not is_transformed:
+            # Node 3 → Node 6 : où a-t-il été cultivé ?
+            result.parcours.append(StepLog(
+                node_id="node_3",
+                question="Quel est le niveau de transformation ?",
+                answer="Intrant brut/non transformé",
+            ))
+
+            if _is_france(pays_production):
+                result.parcours.append(StepLog(
+                    node_id="node_6",
+                    question="Où l'intrant brut a-t-il été cultivé ?",
+                    answer="En France",
+                ))
+                result.node_resultat = "node_8"
+                result = _resolve_node_8(matiere_premiere, result)
+            else:
+                result.parcours.append(StepLog(
+                    node_id="node_6",
+                    question="Où l'intrant brut a-t-il été cultivé ?",
+                    answer=f"Hors France — {pays_production}",
+                ))
+                result.node_resultat = "node_9"
+                result = _resolve_node_9(matiere_premiere, pays_production, result)
+
+        else:
+            # Node 3 → Node 7 : où transformé + origine MP brute ?
+            result.parcours.append(StepLog(
+                node_id="node_3",
+                question="Quel est le niveau de transformation ?",
+                answer="Coproduit/intrant transformé",
+            ))
+
+            if _is_france(pays_transformation) and _is_france(pays_production):
+                result.parcours.append(StepLog(
+                    node_id="node_7",
+                    question="Où l'intrant a-t-il été transformé et d'où provient la MP brute ?",
+                    answer="Transformé en France à partir de MP brute française",
+                ))
+                result.node_resultat = "node_10"
+                result = _resolve_node_10(matiere_premiere, result)
+
+            elif _is_france(pays_transformation):
+                result.parcours.append(StepLog(
+                    node_id="node_7",
+                    question="Où l'intrant a-t-il été transformé et d'où provient la MP brute ?",
+                    answer=f"Transformé en France, MP brute de {pays_production or 'origine inconnue'}",
+                ))
+                result.node_resultat = "node_11"
+                result = _resolve_node_11(matiere_premiere, result)
+
+            else:
+                result.parcours.append(StepLog(
+                    node_id="node_7",
+                    question="Où l'intrant a-t-il été transformé et d'où provient la MP brute ?",
+                    answer=f"Transformé hors France — {pays_transformation}",
+                ))
+                result.node_resultat = "node_12"
+                result = _resolve_node_12(matiere_premiere, pays_transformation or pays_production or "", result)
+
+    # ------------------------------------------------------------------
+    # Post-processing : normaliser les unités (t CO2 eq / t produit)
+    # ------------------------------------------------------------------
+    if result.impact_kg_co2_eq is not None and result.unite_source:
+        if "tonne" in result.unite_source:
+            # GFLI : kg CO2 eq / tonne -> t CO2 eq / t
+            result.impact_tonne_co2_eq = result.impact_kg_co2_eq / 1000.0
+        else:
+            # EcoALIM : kg CO2 eq / kg -> t CO2 eq / t (même valeur numérique)
+            result.impact_tonne_co2_eq = result.impact_kg_co2_eq
+
+    # ------------------------------------------------------------------
+    # Post-processing : collecter les candidats alternatifs
+    # ------------------------------------------------------------------
+    result = _collect_candidates(result)
+
+    # Demander au LLM quel candidat est le plus pertinent en cas de doute
+    if not result.match_exact and result.candidats_alternatifs:
+        try:
+            names = [c.get("nom", "") for c in result.candidats_alternatifs if c.get("nom")]
+            rank = llm_service.rank_candidates(result.matiere_premiere, names)
+            result.candidat_recommande = rank.get("best_name")
+            result.candidats_reflexion = rank.get("reasoning")
+        except Exception:
+            result.candidat_recommande = None
+            result.candidats_reflexion = None
+
+    # Générer une justification LLM si le match n'est pas exact et qu'il n'y en a pas
+    if not result.match_exact and not result.justification_alternative and not result.erreur:
+        if result.intrant_utilise and result.impact_kg_co2_eq is not None:
+            try:
+                result.justification_alternative = llm_service.justify_alternative_value(
+                    result.matiere_premiere,
+                    result.intrant_utilise,
+                    result.impact_kg_co2_eq,
+                    result.source_db,
+                )
+            except Exception:
+                result.justification_alternative = (
+                    f"Valeur de '{result.intrant_utilise}' utilisée comme proxy pour "
+                    f"'{result.matiere_premiere}' (matière la plus proche dans {result.source_db})."
+                )
+
+    return result
+
+
+def _collect_candidates(result: CarbonResult) -> CarbonResult:
+    """
+    Après résolution, cherche les autres produits correspondants dans la même
+    base de données pour proposer des alternatives triées par pertinence.
+    """
+    if result.erreur or result.intrant_utilise is None:
+        return result
+
+    matiere = result.matiere_premiere
+    source = result.source_db or ""
+
+    candidates: list[dict] = []
+
+    # Déterminer le pays ISO pour GFLI
+    country_iso = None
+    if result.pays_production:
+        country_iso = _get_country_iso(result.pays_production)
+    if result.pays_transformation:
+        country_iso = _get_country_iso(result.pays_transformation) or country_iso
+
+    # Collecter depuis la source utilisée + l'autre source
+    # D'abord la source principalement utilisée
+    unbounded = not result.match_exact
+    matiere_fr = llm_service.translate_matiere_to_french(matiere)
+    matiere_en = llm_service.translate_matiere_to_english(matiere)
+    if "ECOALIM" in source.upper():
+        candidates.extend(data_loader.get_top_ecoalim_candidates(
+            matiere,
+            pays_production=result.pays_production,
+            pays_transformation=result.pays_transformation,
+            top_n=None if unbounded else 8,
+        ))
+        if matiere_fr.lower() != matiere.lower():
+            candidates.extend(data_loader.get_top_ecoalim_candidates(
+                matiere_fr,
+                pays_production=result.pays_production,
+                pays_transformation=result.pays_transformation,
+                top_n=None if unbounded else 8,
+            ))
+        candidates.extend(data_loader.get_top_gfli_candidates(
+            matiere, country_iso=country_iso, top_n=None if unbounded else 4,
+        ))
+        if matiere_en.lower() != matiere.lower():
+            candidates.extend(data_loader.get_top_gfli_candidates(
+                matiere_en, country_iso=country_iso, top_n=None if unbounded else 4,
+            ))
+    else:
+        # Essayer aussi avec le nom traduit si on est sur GFLI
+        # Le nom d'intrant utilisé contient le terme anglais
+        intrant_base = result.intrant_utilise.split(",")[0].split("/")[0].strip()
+        candidates.extend(data_loader.get_top_gfli_candidates(
+            intrant_base, country_iso=country_iso, top_n=None if unbounded else 8,
+        ))
+        if matiere_en.lower() != matiere.lower():
+            candidates.extend(data_loader.get_top_gfli_candidates(
+                matiere_en, country_iso=country_iso, top_n=None if unbounded else 8,
+            ))
+        candidates.extend(data_loader.get_top_ecoalim_candidates(
+            matiere,
+            pays_production=result.pays_production,
+            pays_transformation=result.pays_transformation,
+            top_n=None if unbounded else 4,
+        ))
+        if matiere_fr.lower() != matiere.lower():
+            candidates.extend(data_loader.get_top_ecoalim_candidates(
+                matiere_fr,
+                pays_production=result.pays_production,
+                pays_transformation=result.pays_transformation,
+                top_n=None if unbounded else 4,
+            ))
+
+    # Dédupliquer, exclure l'intrant sélectionné, et filtrer les faux positifs
+    seen = set()
+    unique_candidates = []
+    intrant_base = ""
+    if result.intrant_utilise:
+        intrant_base = result.intrant_utilise.split(",")[0].split("/")[0].strip().lower()
+
+    for c in candidates:
+        key = (c["nom"], c["source"])
+        if key in seen or c["nom"] == result.intrant_utilise:
+            continue
+        # Pour GFLI, vérifier que le candidat est pertinent
+        if c["source"] == "GFLI" and not _is_name_match(matiere, c["nom"]):
+            # Accepter quand même si ça matche le nom de base de l'intrant validé
+            if intrant_base and _is_name_match(intrant_base, c["nom"]):
+                pass  # OK, même famille de produit
+            elif matiere_en and _is_name_match(matiere_en, c["nom"]):
+                pass  # OK, match en anglais
+            elif matiere_fr and _is_name_match(matiere_fr, c["nom"]):
+                pass  # OK, match en français
+            else:
+                continue  # Faux positif
+        seen.add(key)
+        unique_candidates.append(c)
+
+    result.candidats_alternatifs = unique_candidates
+    return result

llm_service.py

@@ -0,0 +1,717 @@
+"""
+llm_service.py - Intégration avec Mistral AI pour :
+  1. Déterminer si une matière est brute ou transformée (via PDF CIR)
+  2. Trouver le nom correspondant dans GFLI/EcoALIM
+  3. Justifier le choix d'une valeur proche
+"""
+from __future__ import annotations
+
+from typing import Optional
+from mistralai import Mistral
+
+import config
+import data_loader
+
+
+def _get_client() -> Mistral:
+    """Crée un client Mistral."""
+    return Mistral(api_key=config.MISTRAL_API_KEY)
+
+
+def _chat(system_prompt: str, user_prompt: str) -> str:
+    """Appel simple au LLM Mistral."""
+    client = _get_client()
+    response = client.chat.complete(
+        model=config.MISTRAL_MODEL,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+        temperature=0.1,
+        max_tokens=2000,
+    )
+    return response.choices[0].message.content.strip()
+
+
+def _chat_powerful(system_prompt: str, user_prompt: str, temperature: float = 0.2) -> str:
+    """Appel au LLM Mistral avec modèle plus puissant pour analyses complexes."""
+    client = _get_client()
+    response = client.chat.complete(
+        model=config.MISTRAL_MODEL_POWERFUL,
+        messages=[
+            {"role": "system", "content": system_prompt},
+            {"role": "user", "content": user_prompt},
+        ],
+        temperature=temperature,
+        max_tokens=3000,
+    )
+    return response.choices[0].message.content.strip()
+
+# ============================================================================
+# 1. Déterminer si une matière est brute ou transformée
+# ============================================================================
+
+def determine_brut_ou_transforme(matiere_name: str) -> dict:
+    """
+    Utilise le PDF CIR et Mistral pour déterminer si la matière est brute ou transformée.
+    Retourne: {"classification": "brut" | "transforme", "justification": "..."}
+    """
+    pdf_excerpt = data_loader.get_pdf_excerpt(max_chars=12000)
+
+    system_prompt = """Tu es un expert en alimentation animale et en classification des matières premières.
+Tu dois déterminer si une matière première est BRUTE (non transformée, directement issue de la culture/élevage) 
+ou TRANSFORMÉE (ayant subi un procédé de transformation : extraction, toastage, pressage, décorticage, etc.).
+
+Règles :
+- Une matière BRUTE est un intrant directement récolté : grain entier, graine, racine, fourrage.
+  Exemples : blé, orge, maïs grain, soja graine, luzerne (non déshydratée).
+- Une matière TRANSFORMÉE est un coproduit ou un intrant ayant subi un process industriel.
+  Exemples : tourteau de soja, tourteau de colza, son de blé, huile de palme, farine de poisson, 
+  drèches, pulpes, amidon, luzerne déshydratée, tourteau de tournesol décortiqué.
+
+Si le nom contient des mots comme : tourteau, T., drèche, huile, farine, amidon, pulpe, son, 
+coproduit, expeller, extrait, déshydraté, décortiqué, presse, lécithine, mélasse, concentré, 
+gluten, protéine -> c'est TRANSFORMÉ.
+
+Réponds UNIQUEMENT au format JSON :
+{"classification": "brut" | "transforme", "justification": "explication courte"}"""
+
+    user_prompt = f"""Voici un extrait du Catalogue UE des Matières Premières pour contexte :
+---
+{pdf_excerpt[:6000]}
+---
+
+La matière première à classifier est : "{matiere_name}"
+
+Détermine si cette matière est brute ou transformée."""
+
+    try:
+        response = _chat(system_prompt, user_prompt)
+        # Parse JSON from response
+        import json
+        # Try to extract JSON from the response
+        json_start = response.find("{")
+        json_end = response.rfind("}") + 1
+        if json_start >= 0 and json_end > json_start:
+            result = json.loads(response[json_start:json_end])
+            return result
+        return {"classification": "transforme", "justification": "Classification par défaut (réponse non parsable)"}
+    except Exception as e:
+        # Fallback heuristique
+        return _heuristic_classification(matiere_name)
+
+
+def _heuristic_classification(matiere_name: str) -> dict:
+    """Heuristique simple si le LLM n'est pas disponible."""
+    name_lower = matiere_name.lower().strip()
+    transformed_keywords = [
+        "tourteau", "t.", "t ", "drèche", "huile", "farine", "amidon",
+        "pulpe", "son ", "coproduit", "expeller", "extrait", "déshydrat",
+        "décortiq", "press", "lécithine", "mélasse", "concentré",
+        "gluten", "protéine", "toasté", "solubles", "issues",
+    ]
+    for kw in transformed_keywords:
+        if kw in name_lower:
+            return {
+                "classification": "transforme",
+                "justification": f"Heuristique : le mot-clé '{kw}' indique un produit transformé.",
+            }
+    return {
+        "classification": "brut",
+        "justification": "Heuristique : aucun indicateur de transformation détecté, classifié comme brut.",
+    }
+
+
+# ============================================================================
+# 2. Trouver le nom correspondant dans GFLI ou EcoALIM
+# ============================================================================
+
+def translate_matiere_to_english(matiere_name: str) -> str:
+    """Traduit un nom de matière première du français vers l'anglais pour GFLI."""
+    system_prompt = """Tu es un traducteur expert en alimentation animale.
+Traduis le nom de matière première français en anglais technique utilisé dans les bases de données 
+d'alimentation animale (comme GFLI).
+
+Traductions courantes :
+- BLE / Blé → Wheat grain
+- ORGE → Barley grain  
+- MAÏS → Maize grain / Corn grain
+- T.TNSL / Tourteau de tournesol → Sunflower meal
+- T. COLZA / Tourteau de colza → Rapeseed meal
+- T. SOJA / Tourteau de soja → Soybean meal
+- LUZERNE → Alfalfa
+- COLZA → Rapeseed
+- TOURNESOL → Sunflower
+- POIS → Peas
+- FEVEROLE → Faba beans / Broad beans
+- SON → Bran
+- DRÈCHE → Distillers grains
+- PULPE → Pulp
+- HUILE → Oil
+- FARINE → Meal / Flour
+- "DEC." / décortiqué → dehulled
+- "EXPELLER" → expeller
+- "48PB" / "48" → high protein / 48% protein
+
+Réponds UNIQUEMENT avec la traduction anglaise, rien d'autre."""
+
+    try:
+        return _chat(system_prompt, f"Traduis : {matiere_name}")
+    except Exception:
+        return matiere_name
+
+
+def translate_matiere_to_french(matiere_name: str) -> str:
+    """Traduit un nom de matière première anglais vers le français pour EcoALIM."""
+    system_prompt = """Tu es un traducteur expert en alimentation animale.
+Traduis le nom de matière première anglais en français technique utilisé dans les bases de données
+d'alimentation animale (comme EcoALIM).
+
+Traductions courantes :
+- Wheat grain → Blé
+- Barley grain → Orge
+- Maize/Corn grain → Maïs
+- Sunflower meal → Tourteau de tournesol
+- Rapeseed meal → Tourteau de colza
+- Soybean meal → Tourteau de soja
+- Alfalfa → Luzerne
+- Rapeseed → Colza
+- Sunflower → Tournesol
+- Peas → Pois
+- Faba beans → Féverole
+- Bran → Son
+- Distillers grains → Drèche
+- Pulp → Pulpe
+- Oil → Huile
+- Meal/Flour → Tourteau/Farine
+- Dehulled → Décortiqué
+"""
+
+    user_prompt = f"""Traduis en français le nom suivant : "{matiere_name}".
+Réponds uniquement par la traduction (pas d'explication)."""
+
+    try:
+        response = _chat(system_prompt, user_prompt)
+        return response.strip().strip('"')
+    except Exception:
+        return matiere_name
+
+
+def _prefilter_gfli_names(matiere: str, available_names: list) -> list:
+    """Pré-filtre les noms GFLI par mots-clés pour réduire la liste envoyée au LLM."""
+    # Correspondances FR -> EN pour pré-filtrage
+    keyword_map = {
+        "ble": ["wheat"], "blé": ["wheat"],
+        "orge": ["barley"], "maïs": ["maize", "corn"], "mais": ["maize", "corn"],
+        "colza": ["rapeseed", "canola"], "tournesol": ["sunflower"],
+        "soja": ["soy", "soybean"], "luzerne": ["alfalfa"],
+        "pois": ["pea"], "féverole": ["faba", "broad bean"], "feverole": ["faba", "broad bean"],
+        "avoine": ["oat"], "seigle": ["rye"], "triticale": ["triticale"],
+        "lin": ["linseed", "flax"], "palme": ["palm"], "copra": ["coconut", "copra"],
+        "manioc": ["cassava"], "betterave": ["sugar beet", "beet"],
+        "pomme de terre": ["potato"], "riz": ["rice"],
+        "drèche": ["distiller"], "dreche": ["distiller"],
+        "pulpe": ["pulp"], "son": ["bran"], "gluten": ["gluten"],
+        "huile": ["oil"], "farine": ["meal", "flour"],
+        "tourteau": ["meal", "cake", "expeller"],
+        "graine": ["seed", "grain"],
+        "poisson": ["fish"], "viande": ["meat", "animal"],
+    }
+    
+    matiere_lower = matiere.lower().strip()
+    search_terms = []
+    
+    # Chercher des mots-clés dans le nom
+    for fr_key, en_keys in keyword_map.items():
+        if fr_key in matiere_lower:
+            search_terms.extend(en_keys)
+    
+    if not search_terms:
+        return available_names[:150]  # fallback
+    
+    # Filtrer
+    filtered = []
+    for name in available_names:
+        name_lower = name.lower()
+        if any(term in name_lower for term in search_terms):
+            filtered.append(name)
+    
+    return filtered if filtered else available_names[:150]
+
+
+def find_matching_name_in_db(
+    matiere_name: str,
+    db_name: str = "GFLI",
+) -> dict:
+    """
+    Utilise Mistral pour trouver le meilleur match dans la base de données.
+    Retourne: {"matched_name": "...", "confidence": "haute|moyenne|basse", "justification": "..."}
+    """
+    if db_name == "GFLI":
+        available_names = data_loader.get_gfli_base_products()
+        # Pré-filtrer avec les mots-clés traduits
+        filtered_names = _prefilter_gfli_names(matiere_name, available_names)
+        names_text = "\n".join(filtered_names[:150])
+    else:
+        available_names = data_loader.get_ecoalim_matieres()
+        names_text = "\n".join(available_names[:200])
+
+    system_prompt = f"""Tu es un expert en alimentation animale et en matières premières pour aliments composés.
+Tu dois trouver dans la base de données {db_name} le nom le plus proche correspondant à une matière première donnée.
+
+IMPORTANT :
+- Tu dois répondre avec le nom EXACT tel qu'il apparaît dans la liste.
+- Si aucune correspondance n'est trouvée, retourne "AUCUN".
+- Donne ta confiance : haute (match exact ou quasi-exact), moyenne (même type de matière), basse (approximation).
+
+Réponds UNIQUEMENT au format JSON :
+{{"matched_name": "nom exact de la liste", "confidence": "haute|moyenne|basse", "justification": "explication"}}"""
+
+    user_prompt = f"""Matière première à chercher : "{matiere_name}"
+
+Liste des matières disponibles dans {db_name} :
+{names_text}
+
+Trouve le meilleur match."""
+
+    try:
+        response = _chat(system_prompt, user_prompt)
+        import json
+        json_start = response.find("{")
+        json_end = response.rfind("}") + 1
+        if json_start >= 0 and json_end > json_start:
+            return json.loads(response[json_start:json_end])
+        return {"matched_name": "AUCUN", "confidence": "basse", "justification": "Réponse non parsable"}
+    except Exception as e:
+        return {"matched_name": "AUCUN", "confidence": "basse", "justification": f"Erreur LLM : {e}"}
+
+
+# ============================================================================
+# 3. Justifier le choix d'une valeur proche
+# ============================================================================
+
+def justify_alternative_value(
+    matiere_originale: str,
+    matiere_utilisee: str,
+    valeur: float,
+    source: str,
+) -> str:
+    """
+    Génère une justification par le LLM sur pourquoi on utilise la valeur
+    d'une matière alternative quand la matière exacte n'existe pas.
+    """
+    system_prompt = """Tu es un expert en analyse du cycle de vie (ACV) et en alimentation animale.
+Tu dois justifier pourquoi la valeur d'impact carbone d'une matière première alternative 
+a été choisie pour remplacer une matière première non trouvée dans les bases de données.
+
+Donne une explication concise et technique (3-5 phrases max) en français.
+Mentionne les similitudes agricoles, nutritionnelles ou de process qui justifient ce choix."""
+
+    user_prompt = f"""La matière première recherchée était : "{matiere_originale}"
+Elle n'a pas été trouvée directement dans les bases de données.
+
+La valeur utilisée est celle de : "{matiere_utilisee}"
+Valeur d'impact carbone : {valeur:.4f} (source : {source})
+
+Justifie ce choix de substitution."""
+
+    try:
+        return _chat(system_prompt, user_prompt)
+    except Exception:
+        return (
+            f"Valeur de '{matiere_utilisee}' utilisée comme proxy pour '{matiere_originale}' "
+            f"car c'est la matière la plus proche disponible dans {source}."
+        )
+
+
+# ============================================================================
+# 4. Recherche intelligente avec fallback LLM
+# ============================================================================
+
+def smart_search_ecoalim(
+    matiere: str,
+    pays_production: Optional[str] = None,
+    pays_transformation: Optional[str] = None,
+) -> Optional[dict]:
+    """
+    Recherche intelligente dans EcoALIM : d'abord recherche directe,
+    puis si pas de résultat, utilise le LLM pour trouver un match.
+    Retourne un dict avec valeur, nom, source et éventuellement justification.
+    """
+    # Tentative directe
+    result = data_loader.get_ecoalim_climate_value(matiere, pays_production, pays_transformation)
+    if result:
+        val, nom, source = result
+        # Valider que ce n'est pas un faux positif
+        if data_loader.is_name_match(matiere, nom):
+            return {
+                "valeur_kg_co2_eq": val,
+                "nom_intrant": nom,
+                "source": source,
+                "match_exact": True,
+                "justification": None,
+            }
+        # Faux positif — on continue vers le LLM
+
+    # Tentative avec traduction EN->FR
+    matiere_fr = translate_matiere_to_french(matiere)
+    if matiere_fr.lower() != matiere.lower():
+        result = data_loader.get_ecoalim_climate_value(matiere_fr, pays_production, pays_transformation)
+        if not result:
+            result = data_loader.get_ecoalim_climate_value(matiere_fr)
+        if result:
+            val, nom, source = result
+            if data_loader.is_name_match(matiere_fr, nom):
+                return {
+                    "valeur_kg_co2_eq": val,
+                    "nom_intrant": nom,
+                    "source": source,
+                    "match_exact": False,
+                    "justification": f"Traduction automatique : '{matiere}' → '{matiere_fr}'",
+                }
+
+    # Tentative via LLM
+    match_info = find_matching_name_in_db(matiere, "ECOALIM")
+    if match_info.get("matched_name") and match_info["matched_name"] != "AUCUN":
+        matched_name = match_info["matched_name"]
+        result = data_loader.get_ecoalim_climate_value(matched_name, pays_production, pays_transformation)
+        if not result:
+            result = data_loader.get_ecoalim_climate_value(matched_name)
+        if result:
+            val, nom, source = result
+            justif = justify_alternative_value(matiere, nom, val, source)
+            return {
+                "valeur_kg_co2_eq": val,
+                "nom_intrant": nom,
+                "source": source,
+                "match_exact": False,
+                "justification": justif,
+                "llm_match_info": match_info,
+            }
+    return None
+
+
+def smart_search_gfli(
+    matiere: str,
+    country_iso: Optional[str] = None,
+) -> Optional[dict]:
+    """
+    Recherche intelligente dans GFLI : d'abord recherche directe,
+    puis traduction FR→EN, puis si pas de résultat, utilise le LLM pour trouver un match.
+    """
+    # Tentative directe
+    result = data_loader.get_gfli_climate_value(matiere, country_iso)
+    if result:
+        val, nom, source = result
+        # Valider que ce n'est pas un faux positif (ex: "blé" → "blend")
+        if data_loader.is_name_match(matiere, nom):
+            return {
+                "valeur_kg_co2_eq_par_tonne": val,
+                "nom_intrant": nom,
+                "source": source,
+                "match_exact": True,
+                "justification": None,
+            }
+        # Faux positif — on continue vers la traduction / LLM
+
+    # Tentative avec traduction FR→EN
+    matiere_en = translate_matiere_to_english(matiere)
+    if matiere_en.lower() != matiere.lower():
+        result = data_loader.get_gfli_climate_value(matiere_en, country_iso)
+        if result:
+            val, nom, source = result
+            # Traduction nécessaire → pas un match exact
+            if data_loader.is_name_match(matiere_en, nom):
+                return {
+                    "valeur_kg_co2_eq_par_tonne": val,
+                    "nom_intrant": nom,
+                    "source": source,
+                    "match_exact": False,
+                    "justification": f"Traduction automatique : '{matiere}' → '{matiere_en}'",
+                }
+
+    # Tentative avec traduction EN->FR puis FR->EN (double sens)
+    matiere_fr = translate_matiere_to_french(matiere)
+    if matiere_fr.lower() != matiere.lower():
+        matiere_en2 = translate_matiere_to_english(matiere_fr)
+        if matiere_en2.lower() != matiere.lower() and matiere_en2.lower() != matiere_en.lower():
+            result = data_loader.get_gfli_climate_value(matiere_en2, country_iso)
+            if result:
+                val, nom, source = result
+                if data_loader.is_name_match(matiere_en2, nom):
+                    return {
+                        "valeur_kg_co2_eq_par_tonne": val,
+                        "nom_intrant": nom,
+                        "source": source,
+                        "match_exact": False,
+                        "justification": f"Traduction automatique : '{matiere}' → '{matiere_fr}' → '{matiere_en2}'",
+                    }
+
+    # Tentative via LLM
+    match_info = find_matching_name_in_db(matiere, "GFLI")
+    if match_info.get("matched_name") and match_info["matched_name"] != "AUCUN":
+        matched_name = match_info["matched_name"]
+        result = data_loader.get_gfli_climate_value(matched_name, country_iso)
+        if not result and country_iso:
+            # Try without country filter
+            result = data_loader.get_gfli_climate_value(matched_name)
+        if result:
+            val, nom, source = result
+            justif = justify_alternative_value(matiere, nom, val, source)
+            return {
+                "valeur_kg_co2_eq_par_tonne": val,
+                "nom_intrant": nom,
+                "source": source,
+                "match_exact": False,
+                "justification": justif,
+                "llm_match_info": match_info,
+            }
+    return None
+
+
+def rank_candidates(matiere: str, candidates: list[str]) -> dict:
+    """
+    Demande au LLM quel candidat est le plus pertinent et pourquoi.
+    Retourne: {"best_name": "...", "reasoning": "..."}
+    """
+    if not candidates:
+        return {"best_name": "", "reasoning": ""}
+
+    # Garder une taille raisonnable pour le prompt
+    max_items = 40
+    truncated = len(candidates) > max_items
+    cand_list = candidates[:max_items]
+
+    system_prompt = """Tu es un expert en alimentation animale et en ACV.
+Tu dois choisir le candidat le plus pertinent parmi une liste, en tenant compte
+des synonymes et des langues (ex: tournesol = sunflower).
+
+Réponds UNIQUEMENT au format JSON :
+{"best_name": "...", "reasoning": "..."}
+"""
+
+    user_prompt = f"""Matière recherchée : "{matiere}"
+
+Liste de candidats :
+{chr(10).join('- ' + c for c in cand_list)}
+
+Choisis le meilleur candidat et explique brièvement (2-4 phrases)."""
+
+    if truncated:
+        user_prompt += "\n\nNote: la liste a été tronquée pour la requête."
+
+    try:
+        response = _chat(system_prompt, user_prompt)
+        import json
+        json_start = response.find("{")
+        json_end = response.rfind("}") + 1
+        parsed = json.loads(response[json_start:json_end])
+        return {
+            "best_name": parsed.get("best_name", ""),
+            "reasoning": parsed.get("reasoning", ""),
+        }
+    except Exception:
+        return {"best_name": "", "reasoning": ""}
+
+
+def find_similar_material(matiere: str, db_name: str = "GFLI") -> Optional[dict]:
+    """
+    Quand aucune matière exacte n'est trouvée, cherche une matière AVEC UN IMPACT CARBONE SIMILAIRE
+    (itinéraire technique et profil nutritionnel proches).
+    
+    Retourne: {"similar_name": "...", "impact_kg_co2": value, "source": "...", "reasoning": "..."}
+    ou None si aucune suggestion
+    """
+    result = find_alternative_materials(matiere, db_name)
+    if result and result.get("combined"):
+        alt = result["combined"]
+        return {
+            "similar_name": alt["name"],
+            "impact_kg_co2": alt["impact"],
+            "source": alt["source"],
+            "reasoning": alt["reasoning"],
+        }
+    return None
+
+
+def find_alternative_materials(matiere: str, db_name: str = "GFLI", country_hint: Optional[str] = None) -> Optional[dict]:
+    """
+    Propose 4 alternatives quand une matière exacte n'est pas trouvée :
+    1. itinerary : même itinéraire technique (processus similaire, impact comparable)
+    2. locality : même localité/région de production (ou celle fournie en country_hint)
+    3. form : même forme structurelle (graine → graine, oléo → oléo, etc.)
+    4. combined : meilleur compromis réfléchi des 3 critères
+    
+    Args:
+        matiere: Nom de la matière non trouvée
+        db_name: "GFLI" ou "ECOALIM"
+        country_hint: Pays optionnel pour guider la proposition de localité
+    
+    Retourne: {
+        "itinerary": {"name": "...", "impact": value, "source": "...", "reasoning": "..."},
+        "locality": {...},
+        "form": {...},
+        "combined": {...}
+    }
+    ou None si erreur
+    """
+    if db_name == "GFLI":
+        # Récupérer tous les produits GFLI avec leurs valeurs
+        all_products = data_loader.get_gfli_base_products()
+        products_with_values = []
+        for prod in all_products[:100]:
+            val_tuple = data_loader.get_gfli_climate_value(prod)
+            if val_tuple:
+                val, nom, source = val_tuple
+                products_with_values.append({
+                    "name": nom,
+                    "impact": val,
+                    "source": source,
+                })
+        
+        products_text = "\n".join(
+            f"- {p['name']}: {p['impact']:.2f} kg CO2 eq/t" 
+            for p in products_with_values[:50]
+        )
+        
+        system_prompt = """Tu es un expert en alimentation animale, biologie végétale, ACV et sourcing de matières premières.
+Une matière première n'a pas été trouvée dans la base GFLI. 
+Tu dois proposer 4 alternatives avec des critères différents :
+
+1. ITINERARY (itinéraire technique) : même processus agricole/industriel, même impact carbone comparable
+   → Même type de culture (céréale, légumineuse, etc.), même irrigation, même type de récolte
+   
+2. LOCALITY (localité) : même région/zone géographique de production (FR, BR, etc.)
+   → Même pays/région, même climat agricole, même disponibilité
+   
+3. FORM (forme structurelle) : MÊME GENRE BOTANIQUE OU TRÈS PROCHE (priorité au genre)
+   → Épautre (Triticum dicoccum) = BLÉS/Wheat (genres Triticum, pas Hordeum/Barley)
+   → Orge (Hordeum vulgare) = rester Orge/Barley
+   → Pois (Pisum) = Pois/Pea, pas Broad beans ou autre légumineuse
+   → Graine générique → propose autres graines du MÊME genre si possible
+   → Légumineuse → autres légumineuses du même genre
+   → RÈGLE D'OR : respecter le genre botanique (Triticum ≠ Hordeum) !
+   
+4. COMBINED (combo réfléchi) : MEILLEUR choix qui combine les 3 critères de manière cohérente
+   → OBLIGATOIRE : doit toujours avoir une réponse
+   → Souvent c'est une alternative qui balance bien itinerary+locality
+   → Si pas de perfect mix, choisir celui avec le meilleur itinerary + proche géographiquement
+
+Les valeurs en kg CO2 eq/t t'aident à évaluer les impacts.
+
+⚠️ IMPORTANT : 
+- Retourne SEULEMENT les noms qui existent dans la liste
+- combined DOIT TOUJOURS avoir une valeur (ne pas le laisser vide/null)
+- FORM : PRIORITÉ stricte au genre botanique (Triticum→Wheat, Hordeum→Barley, Pisum→Pea, etc.)
+
+Réponds UNIQUEMENT au format JSON :
+{
+  "itinerary": {"name": "nom exact", "reasoning": "raison technique"},
+  "locality": {"name": "nom exact", "reasoning": "raison géographique"},
+  "form": {"name": "nom exact", "reasoning": "raison structurelle avec même genre botanique"},
+  "combined": {"name": "nom exact", "reasoning": "raison du meilleur compromis"}
+}"""
+
+        user_prompt = f"""Matière non trouvée : "{matiere}"
+
+Produits GFLI disponibles :
+{products_text}
+
+Propose 4 alternatives avec les 4 critères différents.
+⚠️ CRITICAL : Si la matière est épautre/blé (Triticum), propose un WHEAT (genre Triticum), PAS d'orge/barley !
+⚠️ IMPORTANT : combined DOIT TOUJOURS avoir une valeur (jamais null/vide) !"""
+        if country_hint:
+            user_prompt += f"\n⚠️ LOCALITÉ : Pays spécifié = {country_hint}. Privilégie une alternative produite dans ce pays ou proche (même région)."
+        
+    else:  # EcoALIM
+        all_products = data_loader.get_ecoalim_matieres()
+        products_with_values = []
+        for prod in all_products[:100]:
+            val_tuple = data_loader.get_ecoalim_climate_value(prod)
+            if val_tuple:
+                val, nom, source = val_tuple
+                products_with_values.append({
+                    "name": nom,
+                    "impact": val * 1000,
+                    "source": source,
+                })
+        
+        products_text = "\n".join(
+            f"- {p['name']}: {p['impact']:.2f} kg CO2 eq/t" 
+            for p in products_with_values[:50]
+        )
+        
+        system_prompt = """Tu es un expert en alimentation animale, ACV et sourcing.
+Une matière première n'a pas été trouvée dans EcoALIM. 
+Propose 4 alternatives :
+1. ITINERARY : même itinéraire technique/process
+2. LOCALITY : même provenance géographique
+3. FORM : même catégorie structurelle
+4. COMBINED : meilleur compromis réfléchi
+
+Réponds UNIQUEMENT au format JSON avec les 4 alternatives."""
+
+        user_prompt = f"""Matière non trouvée : "{matiere}"
+
+Produits disponibles :
+{products_text}
+
+Propose 4 alternatives avec les 4 critères."""
+        if country_hint:
+            user_prompt += f"\n⚠️ LOCALITÉ : Pays spécifié = {country_hint}. Privilégie une alternative produite dans ce pays ou proche (même région)."
+    
+    try:
+        response = _chat_powerful(system_prompt, user_prompt, temperature=0.3)
+        import json
+        json_start = response.find("{")
+        json_end = response.rfind("}") + 1
+        parsed = json.loads(response[json_start:json_end])
+        
+        result_dict = {}
+        
+        for criterion in ["itinerary", "locality", "form", "combined"]:
+            criterion_data = parsed.get(criterion, {})
+            similar_name = criterion_data.get("name")
+            reasoning = criterion_data.get("reasoning", "")
+            
+            if not similar_name or similar_name.lower() == "null":
+                result_dict[criterion] = None
+                continue
+            
+            # Récupérer la valeur de la matière
+            if db_name == "GFLI":
+                val_tuple = data_loader.get_gfli_climate_value(similar_name)
+                if val_tuple:
+                    val, nom, source = val_tuple
+                    result_dict[criterion] = {
+                        "name": nom,
+                        "impact": val,
+                        "source": source,
+                        "reasoning": reasoning,
+                    }
+            else:  # EcoALIM
+                val_tuple = data_loader.get_ecoalim_climate_value(similar_name)
+                if val_tuple:
+                    val, nom, source = val_tuple
+                    result_dict[criterion] = {
+                        "name": nom,
+                        "impact": val,
+                        "source": source,
+                        "reasoning": reasoning,
+                    }
+        
+        # Fallback pour combined : si vide, utiliser itinerary (meilleur impact technique)
+        if not result_dict.get("combined") and result_dict.get("itinerary"):
+            result_dict["combined"] = {
+                "name": result_dict["itinerary"]["name"],
+                "impact": result_dict["itinerary"]["impact"],
+                "source": result_dict["itinerary"]["source"],
+                "reasoning": f"Meilleur compromis technique : {result_dict['itinerary']['reasoning']}"
+            }
+        
+        if any(result_dict.values()):
+            return result_dict
+        return None
+        
+    except Exception as e:
+        return None

logigramme.json

@@ -0,0 +1,163 @@
+{
+  "metadata": {
+    "titre": "LOGIGRAMME POUR UNE MP VEGETALE ET ANIMALE",
+    "exclusion": "HORS PRODUIT DERIVE DU SOJA",
+    "description": "Logigramme d'aide pour faciliter l'application du Guide de calcul de l'impact carbone des aliments composés, construit par le GT Carbone.",
+    "regles_generales": [
+      "Le choix des valeurs par défaut de facteur d'émission des intrants relève de la compétence et de la responsabilité des entreprises, qui doivent pouvoir les justifier.",
+      "Il faut attribuer une valeur de facteur d'émission à tous les intrants.",
+      "Si provenance inconnue : retenir le facteur d'émission le plus défavorable.",
+      "Si provenance connue mais donnée précise inexistante : prendre la donnée générique disponible la plus pertinente.",
+      "Si absence dans GFLI ou ECOALIM : possibilité d'utiliser d'autres bases reconnues (ex: Agribalyse) à condition de justifier le choix."
+    ]
+  },
+  "flowchart": {
+    "start_node": "node_1",
+    "nodes": [
+      {
+        "id": "node_1",
+        "type": "question",
+        "text": "Connaissez-vous l'endroit où l'intrant a été cultivé ou produit ?",
+        "options": [
+          {
+            "label": "Je ne sais pas où l'intrant a été cultivé/produit",
+            "next_node": "node_2"
+          },
+          {
+            "label": "Je sais où l'intrant a été cultivé/produit",
+            "next_node": "node_3"
+          }
+        ]
+      },
+      {
+        "id": "node_2",
+        "type": "question",
+        "text": "Quel est le niveau de transformation de l'intrant ?",
+        "options": [
+          {
+            "label": "Il s'agit d'un intrant brut/non transformé",
+            "next_node": "node_4"
+          },
+          {
+            "label": "Il s'agit d'un coproduit/d'un intrant transformé",
+            "next_node": "node_5"
+          }
+        ]
+      },
+      {
+        "id": "node_3",
+        "type": "question",
+        "text": "Quel est le niveau de transformation de l'intrant ?",
+        "options": [
+          {
+            "label": "Il s'agit d'un intrant brut/non transformé",
+            "next_node": "node_6"
+          },
+          {
+            "label": "Il s'agit d'un coproduit/d'un intrant transformé",
+            "next_node": "node_7"
+          }
+        ]
+      },
+      {
+        "id": "node_4",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la valeur la plus défavorable pour l'intrant dans le GFLI",
+          "2. Si elle n'existe pas dans le GFLI, je prends la valeur pour l'intrant la plus défavorable dans ECOALIM",
+          "3. Si la valeur n'existe pas, j'utilise la valeur GFLI pour l'intrant qui a le schéma cultural le plus proche"
+        ]
+      },
+      {
+        "id": "node_5",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la valeur la plus défavorable pour l'intrant transformé dans le GFLI",
+          "2. Si elle n'existe pas dans le GFLI, je prends la valeur pour l'intrant la plus défavorable dans ECOALIM",
+          "3. Si la valeur n'existe pas, j'utilise la valeur GFLI pour l'intrant transformé qui a le schéma cultural ou le process le plus proche"
+        ]
+      },
+      {
+        "id": "node_6",
+        "type": "question",
+        "text": "Où l'intrant brut a-t-il été cultivé ?",
+        "options": [
+          {
+            "label": "L'intrant est cultivé en France",
+            "next_node": "node_8"
+          },
+          {
+            "label": "L'intrant n'a pas été cultivé en France",
+            "next_node": "node_9"
+          }
+        ]
+      },
+      {
+        "id": "node_7",
+        "type": "question",
+        "text": "Où l'intrant a-t-il été transformé et d'où provient la matière première brute ?",
+        "options": [
+          {
+            "label": "L'intrant a été transformé en France à partir d'une matière première brute française",
+            "next_node": "node_10"
+          },
+          {
+            "label": "L'intrant est transformé en France mais je ne connais pas la provenance de l'intrant brut ou l'intrant brut ne provient pas de France",
+            "next_node": "node_11"
+          },
+          {
+            "label": "L'intrant est transformé hors France",
+            "next_node": "node_12"
+          }
+        ]
+      },
+      {
+        "id": "node_8",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la valeur pour l'intrant dans ECOALIM",
+          "2. Si elle n'existe pas, je prends la valeur de l'intrant dans le GFLI",
+          "3. Si la valeur n'existe pas, je prends une donnée d'un intrant qui a la pratique culturale la plus proche dans ECOALIM"
+        ]
+      },
+      {
+        "id": "node_9",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la valeur pour l'intrant du pays correspondant dans le GFLI",
+          "2. Si la valeur n'existe pas : Je prends la valeur Mix Européen (RER) du GFLI si l'intrant provient d'Europe. Je prends la valeur du Mix Monde (GLO) du GFLI si l'intrant vient d'un autre continent",
+          "3. Si la valeur n'existe pas, je prends la valeur pour l'intrant correspondant dans ECOALIM"
+        ]
+      },
+      {
+        "id": "node_10",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la valeur correspondant à cet intrant transformé dans ECOALIM",
+          "2. Si la valeur n'existe pas : A/ Si je connais de manière fiable l'impact du process de transformation, je pars de la valeur pour l'intrant brut dans ECOALIM et j'ajoute l'impact du process. B/ Si je ne connais pas de manière fiable l'impact du process, j'utilise la valeur GFLI si elle existe",
+          "3. Si cela n'est pas possible, je prends la valeur d'un intrant qui a le process le plus proche dans ECOALIM"
+        ]
+      },
+      {
+        "id": "node_11",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la valeur France indiquée pour l'intrant dans le GFLI",
+          "2. Si la valeur n'existe pas : A/ Si je connais de manière fiable l'impact du process, je pars de la valeur pour l'intrant brut dans le GFLI et j'ajoute l'impact du process. B/ Si je ne connais pas de manière fiable l'impact du process, je prends la valeur GFLI du Mix Européen (RER)",
+          "3. Si cela n'est pas possible, je prends la valeur pour l'intrant correspondant dans ECOALIM",
+          "4. Si la valeur n'existe pas, je prends la valeur d'un intrant qui a la pratique culturale la plus proche dans le GFLI"
+        ]
+      },
+      {
+        "id": "node_12",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la valeur GFLI du pays correspondant",
+          "2. Si la valeur n'existe pas : A/ Si je connais de manière fiable l'impact du process, je pars de la valeur pour la MP brute dans le GFLI et j'ajoute l'impact du process. B/ Si je ne connais pas de manière fiable l'impact du process, je prends la valeur GFLI du Mix Européen (RER) si l'intrant provient d'Europe et la valeur du Mix Monde (GLO) si l'intrant vient d'un autre continent",
+          "3. Si cela n'est pas possible, je prends la valeur pour l'intrant correspondant dans ECOALIM",
+          "4. Si la valeur n'existe pas, je prends la valeur d'un intrant qui a la pratique culturale la plus proche dans le GFLI"
+        ]
+      }
+    ]
+  }
+}

logigramme_mineral.json

@@ -0,0 +1,93 @@
+{
+  "metadata": {
+    "titre": "LOGIGRAMME POUR UNE MP MINERALE, UN MICRO INGREDIENT OU UN ADDITIF ",
+    "description": "Ces Logigrammes ont été construits pour faciliter l'application du Guide de calcul de l'impact carbone des aliments composés is constituent un outil d'aide, construit par le GT Carbone réunissant des professionnels des syndicats. [cite: 68]",
+    "regles_generales": [
+      "Le choix des valeurs précises de facteur d'émission des intrants relève de la compétence et de la responsabilité des entreprises. [cite: 69, 70]",
+      "A ce titre, elles doivent être en mesure de justifier les choix effectués. [cite: 71]",
+      "La bonne application du guide de calcul de l'impact carbone impose d'attribuer une valeur de facteur d'émission à tous les intrants. [cite: 72]",
+      "Lorsque l'entreprise ne connait pas la provenance d'un intrant, il conviendra de retenir par défaut le facteur d'émission le plus défavorable de l'intrant en question. [cite: 73]",
+      "Lorsque l'entreprise connait la provenance de l'intrant mais que la donnée précise n'existe pas, il conviendra de prendre la donnée générique disponible la plus pertinente. [cite: 74]",
+      "Lorsque les données ne sont pas présentes dans la base de données GFLI ou ECOALIM, les opérateurs peuvent s'orienter vers d'autres bases reconnues (tel agribalyse par exemple) dans la mesure où ils sont en capacité de jusitifier le choix effectué. [cite: 75]"
+    ],
+    "point_entree": "Ma MP est une MP minérale, un micro ingrédient ou un additif [cite: 76, 77, 78, 79, 80, 81]"
+  },
+  "flowchart": {
+    "start_node": "node_1",
+    "nodes": [
+      {
+        "id": "node_1",
+        "type": "question",
+        "text": "Connaissez-vous l'origine de l'intrant (pays de production) ?",
+        "options": [
+          {
+            "label": "Je connais l'origine de l'intrant (pays de production) [cite: 82, 83]",
+            "next_node": "node_2"
+          },
+          {
+            "label": "Je ne connais pas l'origine de l'intrant [cite: 105]",
+            "next_node": "node_3"
+          }
+        ]
+      },
+      {
+        "id": "node_2",
+        "type": "question",
+        "text": "Dans quelle(s) base(s) de données l'intrant est-il présent ?",
+        "options": [
+          {
+            "label": "Si l'intrant est présent dans le GFLI [cite: 84]",
+            "next_node": "node_4"
+          },
+          {
+            "label": "Si l'intrant n'est pas présent dans le GFLI mais est présent dans ECOALIM [cite: 85]",
+            "next_node": "node_5"
+          },
+          {
+            "label": "Si l'intrant n'est présent ni dans GFLI ni dans ECOALIM [cite: 86]",
+            "next_node": "node_6"
+          }
+        ]
+      },
+      {
+        "id": "node_3",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. J'utilise la donnée de l'intrant la plus défavorable dans le GFLI [cite: 106]",
+          "2. Si l'intrant n'est pas dans le GFLI, j'utilise la donnée de l'intrant la plus défavorable dans ECOALIM [cite: 107]",
+          "3. En dernier recours, je prends la donnée Total Minerals, Additives, Vitamins dans GFLI [cite: 108]"
+        ]
+      },
+      {
+        "id": "node_4",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. J'utilise la donnée dans le GFLI s'il y a une valeur précise pour le couple intrant/pays (valeur Espagne pour un intrant venant d'Espagne) [cite: 87]",
+          "2. S'il n'y a pas de valeur précise pour le couple intrant/pays dans le GFLI, je prends la donnée ECOALIM précise pour le couple intrant/pays (valeur Espagne pour un intrant venant d'Espagne) [cite: 90]",
+          "3. Si elle n'existe pas, je prends la donnée de l'intrant dans le GFLI pour une autre provenance : En 1ère intention, je prends la valeur du continent (valeur Europe pour un intrant provenant d'Espagne) [cite: 95, 96, 97]",
+          "4. Si ce n'est pas possible, je prends la valeur d'un pays du même continent (si plusieurs valeurs sont disponibles, je prends la plus défavorable) dans le GFLI (ex: valeur Portugal par exemple pour un intrant venant d'Espagne) [cite: 98, 99]",
+          "5. Si cela n'est pas possible, je prends la valeur monde dans GFLI [cite: 101]",
+          "6. Si cela n'est pas possible, je prends la valeur pour un autre pays, qui n'est pas sur le même continent, dans le GFLI. S'il existe plusieurs options, je prends la plus défavorable. [cite: 104]"
+        ]
+      },
+      {
+        "id": "node_5",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la donnée Ecoalim précise pour le couple intrant/pays si elle existe (valeur Espagne pour un intrant venant d'Espagne) [cite: 88]",
+          "2. Si la valeur n'existe pas, je prends la donnée de l'intrant dans ECOALIM pour une autre provenance : En 1ère intention, je prends la valeur du continent (valeur Europe pour un intrant provenant d'Espagne) [cite: 91, 92]",
+          "3. Si ce n'est pas possible, je prends la valeur d'un pays du même continent (si plusieurs valeurs sont disponibles, je prends la plus défavorable) dans Ecoalim (ex: valeur Portugal par exemple pour un intrant venant d'Espagne) [cite: 93, 94]",
+          "4. Si cela n'est pas possible, je prends la valeur monde dans Ecoalim [cite: 100]",
+          "5. Si cela n'est pas possible, je prends la valeur pour un autre pays, qui n'est pas sur le même continent, dans Ecoalim. S'il existe plusieurs options, je prends la valeur la plus défavorable [cite: 102, 103]"
+        ]
+      },
+      {
+        "id": "node_6",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1. Je prends la donnée Total Minerals, Additives, Vitamins dans GFLI [cite: 89]"
+        ]
+      }
+    ]
+  }
+}

logigramme_soja.json

@@ -0,0 +1,124 @@
+{
+  "metadata": {
+     "titre": "LOGIGRAMME POUR UNE MP DERIVE DU SOJA [cite: 109]",
+     "description": "Ces Logigrammes ont été construits pour faciliter l'application du Guide de calcul de l'impact carbone des aliments composés[cite: 110].  Ils constituent un outil d'aide, construit par le GT Carbone réunissant des professionnels des syndicats[cite: 111].",
+    "regles_generales": [
+       "Le choix des valeurs précises de facteur d'émission des intrants relève de la compétence et de la responsabilité des entreprises[cite: 112, 113].",
+       "A ce titre, elles doivent être en mesure de justifier les choix effectués[cite: 114].",
+       "La bonne application du guide de calcul de l'impact carbone impose d'attribuer une valeur de facteur d'émission à tous les intrants[cite: 115].",
+       "Lorsque l'entreprise ne connait pas la provenance d'un intrant, il conviendra de retenir par défaut le facteur d'émission le plus défavorable de l'intrant en question[cite: 116].",
+       "Lorsque l'entreprise connait la provenance de l'intrant mais que la donnée précise n'existe pas, il conviendra de prendre la donnée générique disponible la plus pertinente[cite: 117].",
+       "Lorsque les données ne sont pas présentes dans la base de données GFLI ou ECOALIM, les opérateurs peuvent s'orienter vers d'autres bases reconnues (tel agribalyse par exemple) dans la mesure où ils sont en capacité de justifier le choix effectué[cite: 118]."
+    ],
+     "point_entree": "Mon intrant est une matière première dérivée du soja [cite: 119, 120, 121]"
+  },
+  "flowchart": {
+    "start_node": "node_1",
+    "nodes": [
+      {
+        "id": "node_1",
+        "type": "question",
+        "text": "Connaissez-vous le pays d'origine de la graine à l'origine de l'intrant ?",
+        "options": [
+          {
+             "label": "Je connais le pays d'origine de la graine à l'origine de l'intrant [cite: 122]",
+            "next_node": "node_2"
+          },
+          {
+             "label": "Je ne connais pas le pays d'origine de la graine à l'origine de l'intrant \"soja ou produit dérivé du soja\" [cite: 136]",
+            "next_node": "node_3"
+          }
+        ]
+      },
+      {
+        "id": "node_2",
+        "type": "question",
+        "text": "Quel est le niveau de transformation de l'intrant ?",
+        "options": [
+          {
+             "label": "L'intrant est du soja non transformé (= des graines de soja crues) [cite: 123]",
+            "next_node": "node_4"
+          },
+          {
+             "label": "L'intrant est un produit dérivé du soja [cite: 124]",
+            "next_node": "node_5"
+          }
+        ]
+      },
+      {
+        "id": "node_3",
+        "type": "question",
+        "text": "Quel est le niveau de transformation de l'intrant ?",
+        "options": [
+          {
+             "label": "L'intrant est du soja non transformé (= des graines crues de soja) [cite: 137]",
+            "next_node": "node_6"
+          },
+          {
+             "label": "L'intrant est un produit dérivé du soja [cite: 138]",
+            "next_node": "node_7"
+          }
+        ]
+      },
+      {
+        "id": "node_4",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1.  Je prends la valeur \"graines\" du pays correspondant dans ECOALIM[cite: 125].",
+          "2.  Si la valeur n'existe pas, je prends la valeur \"graines\" du pays correspondant dans GFLI[cite: 126].",
+          "3.  Si la valeur n'existe pas, je prends la valeur GFLI du Mix Européen (RER) pour des graines crues provenant d'Europe et la valeur GFLI du Mix Monde (GLO) pour des graines crues provenant d'un autre continent[cite: 133]."
+        ]
+      },
+      {
+        "id": "node_5",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1.  Si le couple \"intrant\" \"origine de la graine\" existe dans ECOALIM, je prends une valeur dans ECOALIM[cite: 127].  S'il y a plusieurs lieux de transformation, je prends la valeur du lieu de transformation correspondant à ma situation[cite: 128].  Si le lieu de transformation n'existe pas ou si je ne connais pas le lieu de transformation de mon intrant, je prends la valeur la plus défavorable pour le couple \"intrant\" \"origine de la graine\"[cite: 129].",
+          "2.  Si le couple \"intrant\" \"origine de la graine\" n'existe pas dans ECOALIM : 1/ Si je connais de manière fiable l'impact du process de transformation (sans génération de coproduits), je pars de la valeur pour les graines crues dans ECOALIM et j'ajoute l'impact du process[cite: 130, 131].  2/ Si je ne connais pas de manière fiable l'impact du process de transformation, je prends dans le GFLI la valeur \"produit dérivé du soja\" pour le pays de transformation correspondant ou la valeur la plus défavorable si je ne connais pas le lieu de transformation[cite: 132].",
+          "3.  Si cela n'est pas possible, je prends la valeur GFLI du Mix Européen (RER) si le soja transformé provient d'Europe ou la valeur GFLI du Mix Monde (GLO) si le soja transformé vient d'un autre continent[cite: 134].",
+          "4.  En dernier recours, je prends la valeur pour l'intrant, intégrant le process le plus proche, disponible dans ECOALIM ou GFLI[cite: 135]."
+        ]
+      },
+      {
+        "id": "node_6",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1.  Je prends la valeur \"graines\" la plus défavorable entre les 2 bases de données (GFLI/ECOALIM)[cite: 139]."
+        ]
+      },
+      {
+        "id": "node_7",
+        "type": "question",
+        "text": "Connaissez-vous le lieu de transformation ?",
+        "options": [
+          {
+             "label": "Oui, je connais le lieu de transformation [cite: 140]",
+            "next_node": "node_8"
+          },
+          {
+             "label": "Non, je ne connais pas le lieu de transformation [cite: 142]",
+            "next_node": "node_9"
+          }
+        ]
+      },
+      {
+        "id": "node_8",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1.  Je prends la valeur correspondante au pays de transformation dans ECOALIM si elle existe[cite: 140].  S'il existe plusieurs valeurs pour ce pays de transformation, je prends la valeur la plus défavorable[cite: 141].",
+          "2.  Si la valeur n'existe pas dans ECOALIM, je prends la valeur correspondante au pays de transformation dans le GFLI[cite: 143].",
+          "3.  Si la valeur n'existe pas, je prends la valeur GFLI du Mix Européen (RER) pour le soja transformé provenant d'Europe et la valeur GFLI du Mix Monde (GLO) pour le soja transformé provenant d'un autre continent[cite: 145].",
+          "4.  En dernier recours, je prends la valeur pour l'intrant, intégrant le process le plus proche, disponible dans ECOALIM ou GFLI[cite: 146]."
+        ]
+      },
+      {
+        "id": "node_9",
+        "type": "resultat",
+        "actions_priorisees": [
+          "1.  Je prends la valeur la plus défavorable pour cet intrant entre les 2 bases de données (GFLI /ECOALIM)[cite: 142].",
+          "2.  En dernier recours, je prends la valeur pour l'intrant, intégrant le process le plus proche, disponible dans ECOALIM ou GFLI[cite: 144]."
+        ]
+      }
+    ]
+  }
+}

requirements.txt

@@ -4,4 +4,3 @@ pdfplumber>=0.11.0
 pandas>=2.0.0
 openpyxl>=3.1.0
 python-dotenv>=1.0.0
-datasets>=4.5.0