use glfi ecoalim (#17)

- use synonym data (ee99e09542c3ded23092d20cf7588028c23d9b92)

src/data_loader.py

@@ -272,7 +272,7 @@ def search_gfli(
         # Filtrage strict : si un pays est demandé, ne retourner QUE les résultats de ce pays
         mask = mask & mask_country
 
-    logging.info("Masked df", df[mask].head())
+    logging.info("Masked df: %s", df[mask].head())
     return df[mask].copy()
 
 

src/flowchart_engine.py

@@ -6,6 +6,7 @@ en fonction de la provenance, du niveau de transformation, et des données dispo
 """
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass, field
 from typing import List, Optional, Tuple
 
@@ -13,6 +14,10 @@ import config
 import data_loader
 import llm_service
 
+# Configure logging for flowchart engine
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+
 
 @dataclass
 class StepLog:
@@ -93,7 +98,9 @@ def _is_european(pays: Optional[str]) -> bool:
         return True
     # Try to get ISO from French mapping, or use uppercase input as fallback
     pays_iso = config.PAYS_FR_TO_ISO.get(n, pays.strip().upper())
-    return pays_iso in config.EUROPEAN_COUNTRIES_ISO
+    is_eu = pays_iso in config.EUROPEAN_COUNTRIES_ISO
+    logger.debug(f"_is_european({pays}) → {is_eu} (ISO: {pays_iso})")
+    return is_eu
 
 
 def _get_country_iso(pays: Optional[str]) -> Optional[str]:
@@ -207,7 +214,7 @@ def _resolve_node_4(matiere: str, result: CarbonResult) -> CarbonResult:
     if eco_worst:
         val, nom, src = eco_worst
         result.impact_kg_co2_eq = val
-        result.impact_tonne_co2_eq = val
+        # Note: impact_tonne_co2_eq will be set by post-processing based on unite_source
         result.unite_source = "kg CO2 eq / kg de produit"
         result.source_db = src
         result.intrant_utilise = nom
@@ -301,7 +308,7 @@ def _resolve_node_8(matiere: str, result: CarbonResult) -> CarbonResult:
     if eco_result:
         val = eco_result["valeur_kg_co2_eq"]
         result.impact_kg_co2_eq = val
-        result.impact_tonne_co2_eq = val
+        # Note: impact_tonne_co2_eq will be set by post-processing based on unite_source
         result.unite_source = "kg CO2 eq / kg de produit"
         result.source_db = eco_result["source"]
         result.intrant_utilise = eco_result["nom_intrant"]
@@ -329,7 +336,7 @@ def _resolve_node_8(matiere: str, result: CarbonResult) -> CarbonResult:
     if eco_smart:
         val = eco_smart["valeur_kg_co2_eq"]
         result.impact_kg_co2_eq = val
-        result.impact_tonne_co2_eq = val
+        # Note: impact_tonne_co2_eq will be set by post-processing based on unite_source
         result.unite_source = "kg CO2 eq / kg de produit"
         result.source_db = eco_smart["source"]
         result.intrant_utilise = eco_smart["nom_intrant"]
@@ -401,6 +408,7 @@ def _resolve_node_9(matiere: str, pays_production: str, result: CarbonResult) ->
     """
     country_iso = _get_country_iso(pays_production)
 
+    logger.info(f"Node 9: Étape 1 - Recherche '{matiere}' dans GFLI pour {pays_production} (ISO: {country_iso})")
     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:
@@ -413,11 +421,15 @@ def _resolve_node_9(matiere: str, pays_production: str, result: CarbonResult) ->
         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']}")
+        logger.info(f"✓ Trouvé pays spécifique: {gfli_result['nom_intrant']} = {val:.2f} kg CO2/t")
         return result
+    else:
+        logger.warning(f"✗ Pays spécifique ({country_iso}) non trouvé pour '{matiere}'")
 
     # Étape 2 : RER ou GLO
     is_eu = _is_european(pays_production)
     if is_eu:
+        logger.info(f"Node 9: Pays européen ({pays_production}) → Recherche RER")
         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:
@@ -430,8 +442,13 @@ def _resolve_node_9(matiere: str, pays_production: str, result: CarbonResult) ->
             result.match_exact = rer["match_exact"]
             result.justification_alternative = rer.get("justification")
             result.actions_appliquees.append(f"   → Trouvé RER : {rer['nom_intrant']}")
+            logger.info(f"✓ Trouvé RER: {rer['nom_intrant']} = {val:.2f} kg CO2/t")
             return result
+        else:
+            logger.warning(f"✗ RER non trouvé pour '{matiere}' → Fallback vers ECOALIM")
+            result.actions_appliquees.append(f"   → RER non trouvé pour '{matiere}'")
     else:
+        logger.info(f"Node 9: Pays NON européen ({pays_production}) → Recherche GLO")
         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:
@@ -443,24 +460,34 @@ def _resolve_node_9(matiere: str, pays_production: str, result: CarbonResult) ->
             result.intrant_utilise = glo["nom_intrant"]
             result.match_exact = glo["match_exact"]
             result.justification_alternative = glo.get("justification")
+            logger.info(f"✓ Trouvé GLO: {glo['nom_intrant']} = {val:.2f} kg CO2/t")
             result.actions_appliquees.append(f"   → Trouvé GLO : {glo['nom_intrant']}")
             return result
+        else:
+            logger.warning(f"✗ GLO non trouvé pour '{matiere}' → Fallback vers ECOALIM")
+            result.actions_appliquees.append(f"   → GLO non trouvé pour '{matiere}'")
 
+    logger.info(f"Node 9: Étape 3 - Recherche ECOALIM comme fallback")
     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
+        # Note: impact_tonne_co2_eq will be set by post-processing based on unite_source
         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']}")
+        logger.info(f"✓ Trouvé ECOALIM: {eco_result['nom_intrant']} = {val:.2f} kg CO2/kg")
         return result
+    else:
+        logger.warning(f"✗ ECOALIM non trouvé pour '{matiere}' → Fallback vers alternatives LLM")
+        result.actions_appliquees.append(f"   → ECOALIM non trouvé pour '{matiere}'")
 
     # Étape 4 : Fallback - Proposer des matières alternatives
+    logger.info(f"Node 9: Étape 4 - Recherche d'alternatives via LLM pour '{matiere}'")  
     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)
     
@@ -526,7 +553,7 @@ def _resolve_node_10(matiere: str, result: CarbonResult) -> CarbonResult:
     if eco_result:
         val = eco_result["valeur_kg_co2_eq"]
         result.impact_kg_co2_eq = val
-        result.impact_tonne_co2_eq = val
+        # Note: impact_tonne_co2_eq will be set by post-processing based on unite_source
         result.unite_source = "kg CO2 eq / kg de produit"
         result.source_db = eco_result["source"]
         result.intrant_utilise = eco_result["nom_intrant"]
@@ -548,6 +575,8 @@ def _resolve_node_10(matiere: str, result: CarbonResult) -> CarbonResult:
         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']}")
+        # Update node to reflect that GFLI was used instead of ECOALIM
+        result.node_resultat = "node_base_gfli_fr"
         return result
 
     # Étape 3 : LLM process le plus proche
@@ -556,7 +585,7 @@ def _resolve_node_10(matiere: str, result: CarbonResult) -> CarbonResult:
     if eco_smart:
         val = eco_smart["valeur_kg_co2_eq"]
         result.impact_kg_co2_eq = val
-        result.impact_tonne_co2_eq = val
+        # Note: impact_tonne_co2_eq will be set by post-processing based on unite_source
         result.unite_source = "kg CO2 eq / kg de produit"
         result.source_db = eco_smart["source"]
         result.intrant_utilise = eco_smart["nom_intrant"]
@@ -606,13 +635,16 @@ def _resolve_node_10(matiere: str, result: CarbonResult) -> CarbonResult:
             # 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"
+            # Note: Alternatives from GFLI are in kg CO2 eq / tonne
+            # impact_tonne_co2_eq will be set by post-processing
+            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:.4f} kg CO2 eq/kg")
+            result.actions_appliquees.append(f"   → Matière proposée (combo) : {alt['name']} = {val:.2f} kg CO2 eq/t")
+            # Update node to reflect that GFLI was used (via LLM alternatives)
+            result.node_resultat = "node_base_gfli_alternatives"
             return result
 
     result.erreur = f"Aucune valeur trouvée pour '{matiere}' (transformé, France/France)."
@@ -662,7 +694,7 @@ def _resolve_node_11(matiere: str, result: CarbonResult) -> CarbonResult:
     if eco_result:
         val = eco_result["valeur_kg_co2_eq"]
         result.impact_kg_co2_eq = val
-        result.impact_tonne_co2_eq = val / 1000.0
+        # Note: impact_tonne_co2_eq will be set by post-processing based on unite_source
         result.unite_source = "kg CO2 eq / kg de produit"
         result.source_db = eco_result["source"]
         result.intrant_utilise = eco_result["nom_intrant"]
@@ -792,7 +824,7 @@ def _resolve_node_12(matiere: str, pays_transformation: str, result: CarbonResul
     if eco_result:
         val = eco_result["valeur_kg_co2_eq"]
         result.impact_kg_co2_eq = val
-        result.impact_tonne_co2_eq = val / 1000.0
+        # Note: impact_tonne_co2_eq will be set by post-processing based on unite_source
         result.unite_source = "kg CO2 eq / kg de produit"
         result.source_db = eco_result["source"]
         result.intrant_utilise = eco_result["nom_intrant"]
@@ -1647,6 +1679,9 @@ def evaluate_carbon_impact(
     Returns:
         CarbonResult avec toutes les informations
     """
+    logger.info(f"=== Début évaluation: {matiere_premiere} ===")
+    logger.info(f"Type MP: {type_mp}, Pays production: {pays_production or 'inconnu'}, Pays transformation: {pays_transformation or 'N/A'}")
+    
     result = CarbonResult(
         matiere_premiere=matiere_premiere,
         pays_production=pays_production,
@@ -1662,6 +1697,7 @@ def evaluate_carbon_impact(
         # Les minéraux ne suivent pas la classification brut/transformé
         result.classification = "mineral"
         result.classification_justification = "MP minérale / micro-ingrédient / additif"
+        logger.info(f"Classification: Minérale (pas de classification brut/transformé)")
         result.parcours.append(StepLog(
             node_id="classification",
             question="Type de matière première",
@@ -1672,6 +1708,7 @@ def evaluate_carbon_impact(
         result.classification = classification.get("classification", "brut")
         result.classification_justification = classification.get("justification", "")
         is_transformed = result.classification == "transforme"
+        logger.info(f"Classification: {'Transformée' if is_transformed else 'Brute'} - {result.classification_justification}")
 
         result.parcours.append(StepLog(
             node_id="classification",
@@ -1682,6 +1719,7 @@ def evaluate_carbon_impact(
     # -----------------------------------------------------------------------
     # Dispatch selon le type de MP
     # -----------------------------------------------------------------------
+    logger.info(f"Dispatch vers logigramme: {type_mp}")
     if type_mp == "soja":
         result = _evaluate_soja(matiere_premiere, pays_production, pays_transformation, result)
 
@@ -1695,6 +1733,7 @@ def evaluate_carbon_impact(
 
         if not provenance_connue:
             # node_1 → Non → node_provenance_inconnue
+            logger.info("Node 1: Provenance INCONNUE → Recherche valeur la plus défavorable")
             result.parcours.append(StepLog(
                 node_id="node_1",
                 question="Connaissez-vous l'endroit ou l'intrant a ete cultive ou produit ?",
@@ -1715,10 +1754,12 @@ def evaluate_carbon_impact(
                     answer="Intrant transforme ou coproduit",
                 ))
             result.node_resultat = "node_base_gfli_defaut"
+            logger.info("→ Résolution via Node 4 (valeur la plus défavorable)")
             result = _resolve_node_4(matiere_premiere, result)
 
         else:
             # node_1 → Oui → node_transformation
+            logger.info(f"Node 1: Provenance CONNUE - Production: {pays_production}, Transformation: {pays_transformation or 'N/A'}")
             result.parcours.append(StepLog(
                 node_id="node_1",
                 question="Connaissez-vous l'endroit ou l'intrant a ete cultive ou produit ?",
@@ -1735,6 +1776,7 @@ def evaluate_carbon_impact(
 
                 if _is_france(pays_production):
                     # node_localisation_brut → Oui (France) → node_base_ecoalim
+                    logger.info("Intrant BRUT cultivé en FRANCE → Node 8 (ECOALIM prioritaire)")
                     result.parcours.append(StepLog(
                         node_id="node_localisation_brut",
                         question="L'intrant brut est-il cultive en France ?",
@@ -1744,6 +1786,7 @@ def evaluate_carbon_impact(
                     result = _resolve_node_8(matiere_premiere, result)
                 else:
                     # node_localisation_brut → Non → node_base_gfli_pays
+                    logger.info(f"Intrant BRUT cultivé HORS FRANCE ({pays_production}) → Node 9 (GFLI pays/RER/GLO)")
                     result.parcours.append(StepLog(
                         node_id="node_localisation_brut",
                         question="L'intrant brut est-il cultive en France ?",
@@ -1793,13 +1836,16 @@ def evaluate_carbon_impact(
     # ------------------------------------------------------------------
     # Post-processing : normaliser les unités (t CO2 eq / t produit)
     # ------------------------------------------------------------------
+    logger.info("Post-processing: Normalisation des unités")
     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
+            logger.debug(f"Conversion GFLI: {result.impact_kg_co2_eq} kg CO2/t → {result.impact_tonne_co2_eq} t CO2/t")
         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
+            logger.debug(f"Conversion EcoALIM: {result.impact_kg_co2_eq} kg CO2/kg → {result.impact_tonne_co2_eq} t CO2/t (no numerical change)")
 
     # ------------------------------------------------------------------
     # Post-processing : collecter les candidats alternatifs
@@ -1833,6 +1879,14 @@ def evaluate_carbon_impact(
                     f"'{result.matiere_premiere}' (matière la plus proche dans {result.source_db})."
                 )
 
+    # Log final result
+    if result.erreur:
+        logger.warning(f"=== Évaluation terminée avec ERREUR: {result.erreur} ===")
+    else:
+        logger.info(f"=== Évaluation terminée avec SUCCÈS ===")
+        logger.info(f"Résultat: {result.intrant_utilise} = {result.impact_kg_co2_eq:.2f} {result.unite_source}")
+        logger.info(f"Source: {result.source_db}, Match exact: {result.match_exact}, Node: {result.node_resultat}")
+
     return result
 
 

src/llm_service.py

@@ -6,12 +6,16 @@ llm_service.py - Intégration avec Mistral AI pour :
 """
 from __future__ import annotations
 
+import logging
 from typing import Optional
 from difflib import get_close_matches
 from mistralai import Mistral
 
 import config
 import data_loader
+import synonym_service
+
+logger = logging.getLogger(__name__)
 
 
 def _get_client() -> Mistral:
@@ -339,12 +343,17 @@ def smart_search_ecoalim(
     puis si pas de résultat, utilise le LLM pour trouver un match.
     Retourne un dict avec valeur, nom, source et éventuellement justification.
     """
+    pays_str = f" (production: {pays_production}, transformation: {pays_transformation})" if pays_production or pays_transformation else ""
+    logger.debug(f"smart_search_ecoalim: Recherche '{matiere}'{pays_str}")
+    
     # Tentative directe
+    logger.debug(f"  Stratégie 1: Recherche directe pour '{matiere}'")
     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):
+            logger.debug(f"  ✓ Trouvé par recherche directe: {nom}")
             return {
                 "valeur_kg_co2_eq": val,
                 "nom_intrant": nom,
@@ -353,16 +362,19 @@ def smart_search_ecoalim(
                 "justification": None,
             }
         # Faux positif — on continue vers le LLM
+        logger.debug(f"  ✗ Faux positif détecté pour '{matiere}' → '{nom}'")
 
     # Tentative avec traduction EN->FR
     matiere_fr = translate_matiere_to_french(matiere)
     if matiere_fr.lower() != matiere.lower():
+        logger.debug(f"  Stratégie 2: Traduction EN→FR '{matiere}' → '{matiere_fr}'")
         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):
+                logger.debug(f"  ✓ Trouvé par traduction EN→FR: {nom}")
                 return {
                     "valeur_kg_co2_eq": val,
                     "nom_intrant": nom,
@@ -370,17 +382,21 @@ def smart_search_ecoalim(
                     "match_exact": False,
                     "justification": f"Traduction automatique : '{matiere}' → '{matiere_fr}'",
                 }
+            logger.debug(f"  ✗ Faux positif après traduction EN→FR")
 
     # Tentative via LLM
+    logger.debug(f"  Stratégie 3: Recherche via LLM pour '{matiere}'")
     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"]
+        logger.debug(f"  LLM a suggéré: '{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)
+            logger.debug(f"  ✓ Trouvé via LLM: {nom}")
             return {
                 "valeur_kg_co2_eq": val,
                 "nom_intrant": nom,
@@ -389,6 +405,9 @@ def smart_search_ecoalim(
                 "justification": justif,
                 "llm_match_info": match_info,
             }
+        logger.debug(f"  ✗ Suggestion LLM '{matched_name}' non trouvée dans ECOALIM{pays_str}")
+    
+    logger.debug(f"  ✗ Aucune correspondance trouvée pour '{matiere}'{pays_str}")
     return None
 
 
@@ -400,12 +419,17 @@ def smart_search_gfli(
     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.
     """
+    country_str = f" (pays: {country_iso})" if country_iso else ""
+    logger.debug(f"smart_search_gfli: Recherche '{matiere}'{country_str}")
+    
     # Tentative directe
+    logger.debug(f"  Stratégie 1: Recherche directe pour '{matiere}'")
     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):
+            logger.debug(f"  ✓ Trouvé par recherche directe: {nom}")
             return {
                 "valeur_kg_co2_eq_par_tonne": val,
                 "nom_intrant": nom,
@@ -414,15 +438,18 @@ def smart_search_gfli(
                 "justification": None,
             }
         # Faux positif — on continue vers la traduction / LLM
+        logger.debug(f"  ✗ Faux positif détecté pour '{matiere}' → '{nom}'")
 
     # Tentative avec traduction FR→EN
     matiere_en = translate_matiere_to_english(matiere)
     if matiere_en.lower() != matiere.lower():
+        logger.debug(f"  Stratégie 2: Traduction FR→EN '{matiere}' → '{matiere_en}'")
         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):
+                logger.debug(f"  ✓ Trouvé par traduction FR→EN: {nom}")
                 return {
                     "valeur_kg_co2_eq_par_tonne": val,
                     "nom_intrant": nom,
@@ -430,16 +457,48 @@ def smart_search_gfli(
                     "match_exact": False,
                     "justification": f"Traduction automatique : '{matiere}' → '{matiere_en}'",
                 }
+            logger.debug(f"  ✗ Faux positif après traduction FR→EN")
+
+    # Stratégie 2.5: Recherche via synonymes Feedipedia
+    logger.debug(f"  Stratégie 2.5: Recherche via synonymes Feedipedia")
+    synonyms = synonym_service.get_all_synonyms(matiere)
+    if synonyms:
+        logger.debug(f"    Synonymes trouvés ({len(synonyms)}): {', '.join(synonyms[:5])}{'...' if len(synonyms) > 5 else ''}")
+        for synonym in synonyms:
+            # Skip if we already tried this exact term
+            if synonym.lower() == matiere.lower():
+                continue
+            if matiere_en and synonym.lower() == matiere_en.lower():
+                continue
+            
+            logger.debug(f"    Essai du synonyme '{synonym}'")
+            result = data_loader.get_gfli_climate_value(synonym, country_iso)
+            if result:
+                val, nom, source = result
+                if data_loader.is_name_match(synonym, nom):
+                    logger.debug(f"  ✓ Trouvé via synonyme Feedipedia '{synonym}': {nom}")
+                    return {
+                        "valeur_kg_co2_eq_par_tonne": val,
+                        "nom_intrant": nom,
+                        "source": source,
+                        "match_exact": False,
+                        "justification": f"Synonyme Feedipedia : '{matiere}' → '{synonym}'",
+                    }
+        logger.debug(f"  ✗ Aucun synonyme Feedipedia n'a donné de résultat")
+    else:
+        logger.debug(f"  ✗ Aucun synonyme trouvé dans Feedipedia pour '{matiere}'")
 
     # 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():
+            logger.debug(f"  Stratégie 3: Traduction bidirectionnelle '{matiere}' → '{matiere_fr}' → '{matiere_en2}'")
             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):
+                    logger.debug(f"  ✓ Trouvé par traduction bidirectionnelle: {nom}")
                     return {
                         "valeur_kg_co2_eq_par_tonne": val,
                         "nom_intrant": nom,
@@ -447,15 +506,19 @@ def smart_search_gfli(
                         "match_exact": False,
                         "justification": f"Traduction automatique : '{matiere}' → '{matiere_fr}' → '{matiere_en2}'",
                     }
+                logger.debug(f"  ✗ Faux positif après traduction bidirectionnelle")
 
     # Tentative via LLM
+    logger.debug(f"  Stratégie 4: Recherche via LLM pour '{matiere}'")
     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"]
+        logger.debug(f"  LLM a suggéré: '{matched_name}'")
         result = data_loader.get_gfli_climate_value(matched_name, country_iso)
         if result:
             val, nom, source = result
             justif = justify_alternative_value(matiere, nom, val, source)
+            logger.debug(f"  ✓ Trouvé via LLM: {nom}")
             return {
                 "valeur_kg_co2_eq_par_tonne": val,
                 "nom_intrant": nom,
@@ -464,6 +527,9 @@ def smart_search_gfli(
                 "justification": justif,
                 "llm_match_info": match_info,
             }
+        logger.debug(f"  ✗ Suggestion LLM '{matched_name}' non trouvée dans GFLI{country_str}")
+    
+    logger.debug(f"  ✗ Aucune correspondance trouvée pour '{matiere}'{country_str}")
     return None
 
 

src/synonym_service.py

@@ -0,0 +1,264 @@
+"""
+synonym_service.py - Feedipedia-based synonym lookup for feed materials.
+
+Provides intelligent material name resolution using the feedipedia database:
+- 918 feed entries
+- 1,973 French synonyms
+- 4,742 English synonyms
+
+Usage:
+    from synonym_service import get_all_synonyms
+    
+    synonyms = get_all_synonyms("luzerne")
+    # Returns: ["alfalfa", "lucerne", "luzerne", "luzerne cultivée"]
+"""
+
+import json
+import logging
+import os
+import unicodedata
+from pathlib import Path
+from typing import Dict, List, Set, Optional
+
+logger = logging.getLogger(__name__)
+
+# Module-level cache for loaded synonyms
+_synonym_cache: Optional[Dict[str, List[str]]] = None
+_cache_loaded = False
+
+
+def _normalize_text(text: str) -> str:
+    """
+    Normalize text for matching:
+    - Lowercase
+    - Remove accents
+    - Strip extra whitespace
+    - Remove special characters except hyphens and spaces
+    
+    Examples:
+        "Luzerne" → "luzerne"
+        "MAÏS" → "mais"
+        "Blé  noir" → "ble noir"
+    """
+    if not text:
+        return ""
+    
+    # Lowercase
+    text = text.lower()
+    
+    # Remove accents using Unicode normalization
+    # NFD = decompose characters (é → e + ´)
+    # Then filter out combining marks
+    text = unicodedata.normalize('NFD', text)
+    text = ''.join(char for char in text if unicodedata.category(char) != 'Mn')
+    
+    # Remove extra whitespace
+    text = ' '.join(text.split())
+    
+    return text.strip()
+
+
+def _load_feedipedia() -> Dict[str, List[str]]:
+    """
+    Load feedipedia data and build bidirectional synonym mappings.
+    
+    Returns:
+        Dict mapping normalized terms to lists of all synonyms (denormalized).
+        Example: {"luzerne": ["alfalfa", "lucerne", "luzerne", "luzerne cultivée"]}
+    """
+    # Find the feedipedia file
+    current_dir = Path(__file__).parent
+    feedipedia_path = current_dir / "data" / "feedipedia_feeds.json"
+    
+    if not feedipedia_path.exists():
+        logger.error(f"Feedipedia file not found at {feedipedia_path}")
+        return {}
+    
+    logger.info(f"Loading feedipedia synonyms from {feedipedia_path}")
+    
+    try:
+        with open(feedipedia_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except Exception as e:
+        logger.error(f"Failed to load feedipedia: {e}")
+        return {}
+    
+    # Build synonym mappings
+    # Structure: normalized_term → [all_original_synonyms]
+    synonym_map: Dict[str, Set[str]] = {}
+    
+    feed_count = 0
+    for category, feeds in data.items():
+        for feed in feeds:
+            feed_count += 1
+            
+            # Collect all names for this feed
+            all_names = []
+            
+            # Add feed name (usually "Material (Scientific name)")
+            feed_name = feed.get("feed_name", "")
+            if feed_name:
+                # Extract main name before parenthesis
+                main_name = feed_name.split('(')[0].strip()
+                if main_name:
+                    all_names.append(main_name)
+            
+            # Add English names
+            english_names = feed.get("english_names", [])
+            all_names.extend(english_names)
+            
+            # Add French names
+            french_names = feed.get("french_names", [])
+            all_names.extend(french_names)
+            
+            # Remove duplicates and empty strings
+            all_names = [name for name in all_names if name.strip()]
+            
+            if not all_names:
+                continue
+            
+            # For each name, map its normalized form to ALL names (including itself)
+            for name in all_names:
+                normalized = _normalize_text(name)
+                if normalized:
+                    if normalized not in synonym_map:
+                        synonym_map[normalized] = set()
+                    # Add all other names as synonyms
+                    synonym_map[normalized].update(all_names)
+    
+    logger.info(f"Loaded {feed_count} feeds with {len(synonym_map)} unique normalized terms")
+    
+    # Convert sets to sorted lists for consistent ordering
+    result = {key: sorted(list(values)) for key, values in synonym_map.items()}
+    
+    return result
+
+
+def _get_cache() -> Dict[str, List[str]]:
+    """Get or initialize the synonym cache (lazy loading)."""
+    global _synonym_cache, _cache_loaded
+    
+    if not _cache_loaded:
+        logger.debug("Initializing synonym cache (first use)")
+        _synonym_cache = _load_feedipedia()
+        _cache_loaded = True
+    
+    return _synonym_cache or {}
+
+
+def get_all_synonyms(term: str) -> List[str]:
+    """
+    Get all synonyms for a given term (both French and English).
+    
+    Args:
+        term: Material name in any language (e.g., "luzerne", "Lucerne", "ALFALFA")
+    
+    Returns:
+        List of all synonyms including the original term.
+        Returns empty list if term is unknown.
+    
+    Examples:
+        >>> get_all_synonyms("luzerne")
+        ["alfalfa", "lucerne", "luzerne", "luzerne cultivée"]
+        
+        >>> get_all_synonyms("MAÏS")
+        ["corn", "maize", "maïs"]
+        
+        >>> get_all_synonyms("unknown_material")
+        []
+    """
+    if not term:
+        return []
+    
+    cache = _get_cache()
+    normalized = _normalize_text(term)
+    
+    synonyms = cache.get(normalized, [])
+    
+    if synonyms:
+        logger.debug(f"Found {len(synonyms)} synonyms for '{term}': {synonyms[:5]}...")
+    else:
+        logger.debug(f"No synonyms found for '{term}'")
+    
+    return synonyms
+
+
+def get_english_synonyms(french_term: str) -> List[str]:
+    """
+    Get English synonyms for a French term.
+    
+    Note: This is a convenience function. In practice, get_all_synonyms()
+    returns both French and English, so filtering may be needed.
+    
+    Args:
+        french_term: French material name (e.g., "luzerne")
+    
+    Returns:
+        List of potential English equivalents
+    """
+    all_syns = get_all_synonyms(french_term)
+    
+    # Heuristic: English terms are usually in the original feedipedia english_names
+    # For now, just return all synonyms (caller can filter)
+    return all_syns
+
+
+def get_french_synonyms(english_term: str) -> List[str]:
+    """
+    Get French synonyms for an English term.
+    
+    Args:
+        english_term: English material name (e.g., "alfalfa")
+    
+    Returns:
+        List of potential French equivalents
+    """
+    all_syns = get_all_synonyms(english_term)
+    
+    # Return all synonyms (caller can filter if needed)
+    return all_syns
+
+
+def get_cache_stats() -> Dict[str, int]:
+    """
+    Get statistics about the loaded cache.
+    
+    Returns:
+        Dict with cache statistics
+    """
+    cache = _get_cache()
+    
+    total_terms = len(cache)
+    total_synonyms = sum(len(syns) for syns in cache.values())
+    
+    return {
+        "total_normalized_terms": total_terms,
+        "total_synonym_entries": total_synonyms,
+        "cache_loaded": _cache_loaded,
+    }
+
+
+def clear_cache():
+    """Clear the synonym cache (useful for testing)."""
+    global _synonym_cache, _cache_loaded
+    _synonym_cache = None
+    _cache_loaded = False
+    logger.debug("Synonym cache cleared")
+
+
+# For debugging: print cache stats when module loads in debug mode
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.DEBUG)
+    
+    print("Testing synonym service...")
+    print()
+    
+    # Test luzerne
+    test_terms = ["luzerne", "alfalfa", "lucerne", "blé", "wheat", "orge", "barley", "maïs"]
+    
+    for term in test_terms:
+        syns = get_all_synonyms(term)
+        print(f"{term:20} → {len(syns):3} synonyms: {', '.join(syns[:5])}")
+    
+    print()
+    print("Cache stats:", get_cache_stats())