Initial commit

.gitignore

@@ -0,0 +1,84 @@
+# Variables d'environnement
+.env
+.env.local
+.env.production
+.env.staging
+
+# Environnements virtuels Python
+.venv/
+venv/
+env/
+ENV/
+
+# IDE et éditeurs
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Cache Python
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Gradio
+.gradio/
+gradio_cached_examples/
+
+# Data et modèles (souvent volumineux)
+data/*.parquet
+data/*.csv
+data/*.json
+data/*.pkl
+data/*.db
+*.h5
+*.hdf5
+
+# Logs
+*.log
+logs/
+
+# Fichiers temporaires
+*.tmp
+*.temp
+.DS_Store
+Thumbs.db
+
+# Documentation générée
+docs/_build/
+
+# Fichiers de sauvegarde
+*.bak
+*.backup
+
+# Certificats et clés
+*.pem
+*.key
+*.crt

app.py

@@ -0,0 +1,18 @@
+from ui.gradio_ui import GradioUI
+
+
+def main():
+    print("🚀 Launching...")
+
+    try:
+        ui = GradioUI()
+        demo = ui.create_interface()
+
+        demo.launch(mcp_server=True)
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

config/settings.py

@@ -0,0 +1,9 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY")
+MISTRAL_URL = "https://api.mistral.ai/v1/chat/completions"
+DATA_DIR = os.getenv("DATA_DIR", "./data")
+PARQUET_FILE = os.getenv("PARQUET_FILE", "./data/food.parquet")

requirements.txt

@@ -0,0 +1,9 @@
+gradio~=5.31.0
+mcp
+pandas~=2.2.3
+requests~=2.32.3
+datasets~=3.6.0
+numpy
+huggingface_hub
+duckdb~=1.3.0
+python-dotenv~=1.1.0

services/database_service.py

@@ -0,0 +1,239 @@
+from pathlib import Path
+import duckdb
+from datasets import load_dataset
+import os
+from config.settings import PARQUET_FILE
+
+
+class DatabaseService:
+    def __init__(self):
+        self.parquet_path = None
+        self.conn = None
+
+        os.makedirs('./data', exist_ok=True)
+
+        parquet_file = self._find_parquet_file()
+        if parquet_file and Path(parquet_file).exists():
+            self.parquet_path = Path(parquet_file)
+            self._setup_duckdb()
+            print(f"✅ Dataset : {self.parquet_path}")
+        else:
+            if self._download_from_huggingface():
+                parquet_file = self._find_parquet_file()
+                if parquet_file:
+                    self.parquet_path = Path(parquet_file)
+                    self._setup_duckdb()
+                    print(f"✅ Dataset dowloaded : {self.parquet_path}")
+                else:
+                    print("❌ Can't load dataset")
+                    raise Exception("No dataset")
+            else:
+                print("❌ Can't download dataset")
+                raise Exception("Dataset download failed")
+
+    def _download_from_huggingface(self):
+        """
+        Download dataset from Hugging Face
+        """
+        try:
+            print("🔄 Downloading dataset from Hugging Face...")
+
+
+            dataset_name = "openfoodfacts/product-database"
+
+            dataset = load_dataset(dataset_name, split="train")
+
+            dataset.to_parquet("./data/food.parquet")
+
+            print(f"✅ Dataset downloaded & saved in ./data/food.parquet")
+            return True
+
+        except Exception as e:
+            print(f"❌ Erreur lors du téléchargement depuis Hugging Face: {e}")
+
+
+    def _find_parquet_file(self):
+        paths = [PARQUET_FILE, "./data/food.parquet", "./food.parquet", "../data/food.parquet"]
+        for path in paths:
+            if Path(path).exists():
+                return path
+        return None
+
+    def _setup_duckdb(self):
+        try:
+            self.conn = duckdb.connect()
+            result = self.conn.execute(f"SELECT COUNT(*) FROM '{self.parquet_path}'").fetchone()
+            total = result[0] if result else 0
+            print(f"✅ DuckDB: {total:,} products")
+        except Exception as e:
+            print(f"❌ Error DuckDB: {e}")
+            raise Exception(f"DuckDB can not be configured: {e}")
+
+    def escape_sql_string(self, text):
+        if not text:
+            return ""
+        text = text.replace("'", "''")
+        text = text.replace("%", "%%")
+        return text
+
+    def _clean_tags(self, tags_raw):
+        if not tags_raw:
+            return []
+
+        if isinstance(tags_raw, str):
+            if tags_raw.startswith('['):
+                try:
+                    import ast
+                    tags_list = ast.literal_eval(tags_raw)
+                    if isinstance(tags_list, list):
+                        return [str(tag).replace('en:', '').replace('fr:', '') for tag in tags_list[:3]]
+                except:
+                    pass
+            return [tags_raw]
+
+        if isinstance(tags_raw, list):
+            return [str(tag).replace('en:', '').replace('fr:', '') for tag in tags_raw[:3]]
+
+        return [str(tags_raw)]
+
+    def clean_product_name(self, raw_name):
+        if not raw_name or raw_name == 'N/A':
+            return 'N/A'
+
+        if raw_name.startswith('[') and 'text' in raw_name:
+            try:
+                import re
+                match = re.search(r"'text':\s*'([^']*)'", raw_name)
+                if match:
+                    return match.group(1)
+                match = re.search(r'"text":\s*"([^"]*)"', raw_name)
+                if match:
+                    return match.group(1)
+            except Exception as e:
+                print(f"⚠️ Error cleaning: {e}")
+
+        clean = raw_name.replace('[', '').replace(']', '').replace('{', '').replace('}', '')
+
+        if 'text' in clean:
+            parts = clean.split('text')
+            if len(parts) > 1:
+                text_part = parts[-1]
+                text_part = text_part.replace('"', '').replace("'", '').replace(':', '').replace(',', '')
+                text_part = text_part.strip()
+                if text_part and len(text_part) > 3:
+                    return text_part
+
+        return clean[:100]
+
+    def search_products(self, analysis, limit=1):
+        """
+        Search products in dataset
+        """
+        if not self.conn or not self.parquet_path:
+            print("❌ DAtabase not initialized")
+            return []
+
+        try:
+            product = analysis.get("product", "").strip()
+            brand = analysis.get("brand", "").strip()
+
+            safe_product = self.escape_sql_string(product)
+            safe_brand = self.escape_sql_string(brand)
+            safe_query = self.escape_sql_string(product)
+
+            conditions = []
+            scores = []
+
+            if product and brand:
+                product_condition = f"LOWER(CAST(product_name AS VARCHAR)) LIKE LOWER('%{safe_product}%')"
+                brand_condition = f"LOWER(CAST(brands AS VARCHAR)) LIKE LOWER('%{safe_brand}%')"
+                conditions.append(f"({product_condition} AND {brand_condition})")
+                scores.append(f"CASE WHEN {product_condition} AND {brand_condition} THEN 100 ELSE 0 END")
+                scores.append(
+                    f"CASE WHEN LOWER(CAST(product_name AS VARCHAR)) LIKE LOWER('{safe_product}%') THEN 20 ELSE 0 END")
+                scores.append(f"CASE WHEN LOWER(CAST(brands AS VARCHAR)) = LOWER('{safe_brand}') THEN 30 ELSE 0 END")
+
+            elif product and not brand:
+                product_condition = f"LOWER(CAST(product_name AS VARCHAR)) LIKE LOWER('%{safe_product}%')"
+                conditions.append(product_condition)
+                scores.append(
+                    f"CASE WHEN LOWER(CAST(product_name AS VARCHAR)) LIKE LOWER('{safe_product}%') THEN 80 ELSE 50 END")
+                scores.append("CASE WHEN brands IS NOT NULL AND LENGTH(CAST(brands AS VARCHAR)) > 3 THEN 10 ELSE 0 END")
+
+            elif brand and not product:
+                brand_condition = f"LOWER(CAST(brands AS VARCHAR)) LIKE LOWER('%{safe_brand}%')"
+                conditions.append(brand_condition)
+                scores.append(f"CASE WHEN LOWER(CAST(brands AS VARCHAR)) = LOWER('{safe_brand}') THEN 90 ELSE 60 END")
+
+            else:
+                conditions.append(
+                    f"(LOWER(CAST(product_name AS VARCHAR)) LIKE LOWER('%{safe_query}%') OR LOWER(CAST(brands AS VARCHAR)) LIKE LOWER('%{safe_query}%'))")
+                scores.append(
+                    f"CASE WHEN LOWER(CAST(product_name AS VARCHAR)) LIKE LOWER('%{safe_query}%') THEN 40 ELSE 20 END")
+
+            conditions.append("LOWER(CAST(countries_tags AS VARCHAR)) LIKE '%france%'")
+
+            where_clause = " AND ".join(conditions)
+            score_calc = " + ".join(scores) if scores else "1"
+
+            min_score_threshold = 30
+            where_clause = f"({where_clause}) AND (({score_calc}) >= {min_score_threshold})"
+
+            sql = f"""
+            SELECT DISTINCT
+                product_name,           -- 0
+                brands,                 -- 1
+                nutriscore_grade,       -- 2
+                ecoscore_grade,         -- 3
+                nova_group,             -- 4
+                categories,             -- 5
+                ingredients_n,          -- 6
+                additives_n,            -- 7
+                allergens_tags,         -- 8
+                ingredients_text,       -- 9
+                ingredients_tags,       -- 10
+                nutriments,             -- 11
+                origins,                -- 12
+                serving_size,           -- 13
+                quantity,               -- 14
+                labels_tags,            -- 15
+                ({score_calc}) AS score -- 16
+            FROM '{self.parquet_path}'
+            WHERE {where_clause}
+            ORDER BY score DESC, product_name ASC
+            LIMIT {limit}
+            """
+
+            results = self.conn.execute(sql).fetchall()
+
+            products = []
+            for row in results:
+                raw_name = str(row[0]) if row[0] else 'N/A'
+                clean_name = self.clean_product_name(raw_name)
+
+                products.append({
+                    'product_name': clean_name[:100],
+                    'brands': str(row[1])[:50] if row[1] else 'N/A',
+                    'nutriscore_grade': str(row[2]).lower() if row[2] else '',
+                    'ecoscore_grade': str(row[3]).lower() if row[3] else '',
+                    'nova_group': row[4] if row[4] else None,
+                    'categories': str(row[5])[:100] if row[5] else 'N/A',
+                    'ingredients_count': row[6] if row[6] else 0,
+                    'additives_count': row[7] if row[7] else 0,
+                    'allergens': self._clean_tags(row[8]),
+                    'ingredients_text': str(row[9])[:500] if row[9] else 'N/A',
+                    'ingredients_tags': self._clean_tags(row[10]) if row[10] else [],
+                    'nutriments': (row[11]) if row[11] else 'N/A',
+                    'origins': str(row[12])[:50] if row[12] else 'N/A',
+                    'serving_size': str(row[13])[:20] if row[13] else 'N/A',
+                    'quantity': str(row[14])[:30] if row[14] else 'N/A',
+                    'labels': self._clean_tags(row[15]) if row[15] else [],
+                    'score': float(row[16]) if row[16] else 0.0,
+                    'mistral_analysis': analysis.get('explanation', '')
+                })
+
+            return products
+
+        except Exception as e:
+            print(f"❌ Search error: {e}")
+            return []

services/mistral_service.py

@@ -0,0 +1,87 @@
+import requests
+import json
+from config.settings import MISTRAL_API_KEY, MISTRAL_URL
+
+
+class MistralService:
+    def __init__(self):
+        self.api_key = MISTRAL_API_KEY
+        self.api_url = MISTRAL_URL
+
+    def analyze_query(self, query):
+        """
+        Analyse la requête utilisateur pour distinguer la marque et le produit
+        :param query:
+        :return: JSON
+        """
+
+        if not self.api_key:
+            return {"product": query, "brand": "", "quality_filter": "none", "explanation": "Pas de clé Mistral"}
+
+        prompt = f"""Analyse cette requête de recherche alimentaire, tu es capable de différencier la marque et le produit, et réponds en JSON :
+
+Requête: "{query}"
+
+RÈGLES IMPORTANTES :
+- Si c'est un nom de produit avec parfum/goût (ex: "danette chocolat", "yaourt fraise", "pizza 4 fromages"), alors TOUT est le PRODUIT
+- Séparer produit/marque SEULEMENT si ton analyse en conclue que c'est une marque.
+- Les parfums/goûts/saveurs ne sont PAS des marques : chocolat, vanille, fraise, pistache, caramel, etc.
+
+Réponds uniquement avec ce format JSON :
+{{
+    "product": "nom du produit recherché",
+    "brand": "marque si explicitement une VRAIE marque connue ou vide",
+    "explanation": "explication courte"
+}}
+
+Exemples :
+- "danette pistache" → {{"product": "danette pistache", "brand": "", "quality_filter": "none", "explanation": "Recherche produit Danette parfum pistache"}}
+- "yaourt fraise" → {{"product": "yaourt fraise", "brand": "", "quality_filter": "none", "explanation": "Recherche yaourt parfum fraise"}}
+- "pizza 4 fromages" → {{"product": "pizza 4 fromages", "brand": "", "quality_filter": "none", "explanation": "Recherche pizza 4 fromages"}}
+- "yaourt danone fraise" → {{"product": "yaourt fraise", "brand": "danone", "quality_filter": "none", "explanation": "Yaourt fraise de la marque Danone"}}
+- "pizza picard" → {{"product": "pizza", "brand": "picard", "quality_filter": "none", "explanation": "Pizzas de la marque Picard"}}
+- "nutella" → {{"product": "nutella", "brand": "", "quality_filter": "none", "explanation": "Recherche produit Nutella"}}
+- "coca cola" → {{"product": "coca cola", "brand": "", "quality_filter": "none", "explanation": "Recherche produit Coca Cola"}}
+"""
+
+        try:
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json"
+            }
+
+            data = {
+                "model": "mistral-small",
+                "messages": [{"role": "user", "content": prompt}],
+                "temperature": 0.1,
+                "max_tokens": 200
+            }
+
+            response = requests.post(self.api_url, headers=headers, json=data, timeout=10)
+
+            if response.status_code == 200:
+                result = response.json()
+                content = result["choices"][0]["message"]["content"]
+
+                content = content.strip()
+                if content.startswith("```json"):
+                    content = content[7:]
+                if content.startswith("```"):
+                    content = content[3:]
+                if content.endswith("```"):
+                    content = content[:-3]
+
+                start_idx = content.find('{')
+                end_idx = content.rfind('}')
+                if start_idx != -1 and end_idx != -1:
+                    content = content[start_idx:end_idx + 1]
+
+                analysis = json.loads(content)
+                print(f"🤖 Mistral understand : {analysis.get('explanation', '')}")
+                return analysis
+
+            else:
+                print(f"❌ Mistral API error: {response.status_code}")
+
+        except Exception as e:
+            print(f"❌ Mistral error: {e}")

services/search_service.py

@@ -0,0 +1,377 @@
+import json
+import re
+from typing import List, Dict, Any, Optional
+from services.mistral_service import MistralService
+from services.database_service import DatabaseService
+
+
+class FoodSearchService:
+    """Service pour la recherche et le traitement des données alimentaires"""
+
+    def __init__(self):
+        self.mistral_service = MistralService()
+        self.database_service = DatabaseService()
+
+    def search_products(self, query: str, max_results: int = 5) -> str:
+        """
+        Recherche de produits alimentaires avec analyse intelligente par IA.
+
+        Cette fonction utilise Mistral AI pour comprendre les requêtes en langage naturel
+        et recherche dans la base OpenFoodFacts pour retourner des informations détaillées
+        sur les produits alimentaires.
+
+        Args:
+            query (str): Requête de recherche en langage naturel.
+                Exemples :
+                - "pepito" : recherche tous les produits Pepito
+                - "pizza picard" : pizzas de la marque Picard
+                - "yaourt sans lactose" : yaourts adaptés
+                - "biscuits lu bio" : biscuits LU avec label bio
+
+            max_results (int): Nombre maximum de résultats à retourner (1-20).
+                Défaut: 5
+
+        Returns:
+            str: Résultats formatés en markdown contenant pour chaque produit :
+                - Nom du produit et marque
+                - Scores nutritionnels (Nutri-Score, NOVA)
+                - Composition (nombre d'ingrédients et additifs)
+                - Liste complète des ingrédients
+                - Allergènes présents
+                - Valeurs nutritionnelles (énergie, matières grasses, sucres, sel, protéines)
+                - Informations produit (quantité, portion)
+                - Catégories du produit
+
+        Raises:
+            Exception: En cas d'erreur de recherche ou de connexion à la base de données
+
+        Examples:
+            >>> service = FoodSearchService()
+            >>> results = service.search_products("nutella", 3)
+            >>> print(results)
+            **📊 3 produits trouvés :**
+
+            **1. Nutella**
+            - **Marque**: Ferrero
+            - **Scores**: Nutri: 🔴E | NOVA: 🔴4
+            - **🧾 Ingrédients**: Sucre, huile de palme, noisettes...
+        """
+        if not query.strip():
+            return "❌ Enter your research"
+
+        try:
+            analysis = self.mistral_service.analyze_query(query)
+        except Exception as e:
+            print(f"Mistral not ready: {e}")
+            analysis = {'keywords': [query], 'brand': '', 'category': ''}
+
+        # Rechercher dans la base
+        try:
+            products = self.database_service.search_products(analysis, limit=max_results)
+        except Exception as e:
+            return f"❌ Search error: {str(e)}"
+
+        if not products:
+            return f"❌ No results for '{query}'"
+
+        return self._format_products_results(products)
+
+    def _format_products_results(self, products: List[Dict[str, Any]]) -> str:
+        """Format results in markdown"""
+        result = f"**📊 {len(products)} produits trouvés :**\n\n"
+
+        for i, product in enumerate(products, 1):
+            try:
+                result += self._format_single_product(i, product)
+            except Exception as e:
+                print(f"Error formating product {i}: {e}")
+                result += f"**{i}. Erreur lors du traitement du produit**\n\n"
+                continue
+
+        return result
+
+    def _format_single_product(self, index: int, product: Dict[str, Any]) -> str:
+        """Formate single produdt"""
+        product_name = product.get('product_name', 'Produit inconnu')
+        brand = product.get('brands', 'N/A')
+
+        result = f"**{index}. {product_name}**\n"
+        result += f"- **Marque**: {brand}\n"
+
+        # Scores nutritionnels
+        result += self._format_nutrition_scores(product)
+
+        # Composition
+        result += self._format_composition(product)
+
+        # Ingrédients
+        result += self._format_ingredients(product)
+
+        # Allergènes
+        result += self._format_allergens(product)
+
+        # Valeurs nutritionnelles
+        result += self._format_nutrition_values(product)
+
+        # Informations additionnelles
+        result += self._format_additional_info(product)
+
+        # Catégories
+        result += self._format_categories(product)
+
+        result += "\n"
+        return result
+
+    def _format_nutrition_scores(self, product: Dict[str, Any]) -> str:
+        """Format nutrition scores"""
+        scores_line = []
+
+        # Nutri-Score
+        nutri_grade = product.get('nutriscore_grade')
+        if nutri_grade and nutri_grade != 'unknown':
+            nutri_emoji = self._get_grade_emoji(nutri_grade, 'nutri')
+            scores_line.append(f"Nutri: {nutri_emoji}{nutri_grade.upper()}")
+
+        # Groupe NOVA
+        nova_group = product.get('nova_group')
+        if nova_group:
+            nova_emoji = self._get_grade_emoji(nova_group, 'nova')
+            scores_line.append(f"NOVA: {nova_emoji}{nova_group}")
+
+        return f"- **Scores**: {' | '.join(scores_line)}\n" if scores_line else ""
+
+    def _format_composition(self, product: Dict[str, Any]) -> str:
+        """Format composition (ingrédients/additifs)"""
+        composition_parts = []
+        ingredients_count = product.get('ingredients_count', 0)
+        additives_count = product.get('additives_count', 0)
+
+        if ingredients_count and ingredients_count > 0:
+            composition_parts.append(f"{ingredients_count} ingrédients")
+        if additives_count and additives_count > 0:
+            composition_parts.append(f"⚠️ {additives_count} additifs")
+
+        return f"- **Composition**: {', '.join(composition_parts)}\n" if composition_parts else ""
+
+    def _format_ingredients(self, product: Dict[str, Any]) -> str:
+        """Format ingredients"""
+        ingredients_text = product.get('ingredients_text')
+        if ingredients_text and ingredients_text != 'N/A':
+            ingredients_clean = self._extract_ingredients_text(ingredients_text)
+
+            if ingredients_clean:
+                # Limiter la longueur pour l'affichage
+                if len(ingredients_clean) > 300:
+                    ingredients_display = ingredients_clean[:300] + "..."
+                else:
+                    ingredients_display = ingredients_clean
+                return f"- **🧾 Ingrédients**: {ingredients_display}\n"
+
+        return ""
+
+    def _format_allergens(self, product: Dict[str, Any]) -> str:
+        """Format allergens"""
+        allergens = product.get('allergens', [])
+        if allergens and len(allergens) > 0:
+            allergens_clean = [self._clean_allergen_name(a) for a in allergens[:4]]
+            allergens_clean = [a for a in allergens_clean if a]
+            if allergens_clean:
+                return f"- **⚠️ Allergènes**: {', '.join(allergens_clean)}\n"
+
+        return ""
+
+    def _format_nutrition_values(self, product: Dict[str, Any]) -> str:
+        """Format nutrition values"""
+        nutrients = self._parse_nutrients(product.get('nutriments', {}))
+        nutrition_display = []
+
+        # Ordre d'importance pour l'affichage
+        key_nutrients = [
+            'energy-kcal', 'energy_kcal',
+            'sugars',
+            'fat',
+            'salt', 'sodium',
+            'proteins',
+            'saturated-fat', 'saturated_fat',
+            'carbohydrates'
+        ]
+
+        for nutrient_name in key_nutrients:
+            if nutrient_name in nutrients:
+                formatted_value = self._format_nutrition_value(nutrients[nutrient_name])
+                if formatted_value != "N/A":
+                    display_name = {
+                        'energy-kcal': 'Énergie', 'energy_kcal': 'Énergie',
+                        'fat': 'Matières grasses',
+                        'saturated-fat': 'Sat. grasses', 'saturated_fat': 'Sat. grasses',
+                        'sugars': 'Sucres',
+                        'salt': 'Sel', 'sodium': 'Sel',
+                        'proteins': 'Protéines',
+                        'carbohydrates': 'Glucides'
+                    }.get(nutrient_name, nutrient_name.title())
+                    nutrition_display.append(f"{display_name}: {formatted_value}")
+
+                    if len(nutrition_display) >= 4:
+                        break
+
+        return f"- **🍽️ Nutrition** (100g): {' | '.join(nutrition_display)}\n" if nutrition_display else ""
+
+    def _format_additional_info(self, product: Dict[str, Any]) -> str:
+        """Format additional info"""
+        additional_info = []
+        serving_size = product.get('serving_size')
+        quantity = product.get('quantity')
+
+        if quantity and quantity != 'N/A':
+            additional_info.append(f"📦 {quantity}")
+        if serving_size and serving_size != 'N/A':
+            additional_info.append(f"🥄 Portion: {serving_size}")
+
+        return f"- **ℹ️ Infos**: {' | '.join(additional_info)}\n" if additional_info else ""
+
+    def _format_categories(self, product: Dict[str, Any]) -> str:
+        """Formate categories"""
+        categories = product.get('categories')
+        if categories and categories != 'N/A':
+            cats_clean = categories.replace(',', ' → ').replace('Snacks → ', '')
+            if len(cats_clean) > 60:
+                cats_clean = cats_clean[:60] + "..."
+            return f"- **📂 Catégorie**: {cats_clean}\n"
+
+        return ""
+
+
+    def _get_grade_emoji(self, grade, grade_type='nutri') -> str:
+        """Return grad emoji"""
+        if not grade or grade == 'unknown':
+            return ''
+
+        if grade_type == 'nutri':
+            return {'a': '🟢', 'b': '🟡', 'c': '🟠', 'd': '🔴', 'e': '🔴'}.get(str(grade).lower(), '')
+        elif grade_type == 'nova':
+            return {1: '🟢', 2: '🟡', 3: '🟠', 4: '🔴'}.get(grade, '')
+        return ''
+
+    def _clean_allergen_name(self, allergen: str) -> str:
+        """Clean allergen name"""
+        if not allergen:
+            return allergen
+        cleaned = allergen.replace('en:', '').replace('fr:', '')
+        cleaned = cleaned.replace('-', ' ').title()
+        return cleaned
+
+    def _extract_ingredients_text(self, ingredients_data) -> str:
+        """Extract ingredients list"""
+        if not ingredients_data or ingredients_data == 'N/A':
+            return ""
+
+        try:
+            data_str = str(ingredients_data)
+
+            patterns = [
+                r"'text':\s*'([^']{20,})'",
+                r'"text":\s*"([^"]{20,})"',
+                r"'text':\s*\"([^\"]{20,})\"",
+                r'"text":\s*\'([^\']{20,})\'',
+            ]
+
+            all_matches = []
+            for pattern in patterns:
+                matches = re.findall(pattern, data_str, re.DOTALL)
+                all_matches.extend(matches)
+
+            if all_matches:
+                longest_match = max(all_matches, key=len)
+                return self._clean_ingredients_text(longest_match)
+
+            # Fallback
+            simple_pattern = r"text[^a-zA-Z]*([a-zA-Z][^}]{30,})"
+            simple_matches = re.findall(simple_pattern, data_str)
+            if simple_matches:
+                return self._clean_ingredients_text(simple_matches[0])
+
+        except Exception as e:
+            print(f"Error ingredients extraction: {e}")
+
+        return ""
+
+    def _clean_ingredients_text(self, text: str) -> str:
+        """Clean ingredients text"""
+        if not text:
+            return ""
+
+        text = re.sub(r'<span class="allergen">(.*?)</span>', r'\1', text)
+
+        text = text.replace('\\', '').replace('\\"', '"').replace("\\'", "'")
+        text = text.replace('&quot;', '"')
+
+        text = re.sub(r'\s*%\s*', '% ', text)
+        text = re.sub(r'\s*\(\s*', ' (', text)
+        text = re.sub(r'\s*\)\s*', ') ', text)
+        text = re.sub(r'\s+', ' ', text)
+
+        return text.strip()
+
+    def _parse_nutrients(self, nutrients_data) -> Dict[str, Any]:
+        """Parse nutrients"""
+        if not nutrients_data or nutrients_data == 'N/A':
+            return {}
+
+        try:
+            # Si c'est déjà une liste
+            if isinstance(nutrients_data, list):
+                result = {}
+                for nutrient in nutrients_data:
+                    if isinstance(nutrient, dict) and 'name' in nutrient:
+                        result[nutrient['name']] = nutrient
+                return result
+
+            # Si c'est une chaîne
+            if isinstance(nutrients_data, str):
+                if nutrients_data.startswith('[') and 'name' in nutrients_data:
+                    try:
+                        import ast
+                        nutrients_list = ast.literal_eval(nutrients_data)
+                        if isinstance(nutrients_list, list):
+                            result = {}
+                            for nutrient in nutrients_list:
+                                if isinstance(nutrient, dict) and 'name' in nutrient:
+                                    result[nutrient['name']] = nutrient
+                            return result
+                    except:
+                        pass
+
+                try:
+                    nutrients_list = json.loads(nutrients_data)
+                    result = {}
+                    for nutrient in nutrients_list:
+                        if isinstance(nutrient, dict) and 'name' in nutrient:
+                            result[nutrient['name']] = nutrient
+                    return result
+                except:
+                    pass
+
+        except:
+            pass
+
+        return {}
+
+    def _format_nutrition_value(self, nutrient_data) -> str:
+        """Format nutrition value"""
+        if not nutrient_data:
+            return "N/A"
+
+        value = nutrient_data.get('100g', nutrient_data.get('value', 0))
+        unit = nutrient_data.get('unit', '')
+
+        if value is None or value == 0:
+            return "N/A"
+
+        if 'kcal' in unit.lower():
+            return f"{int(value)} kcal"
+        elif 'kj' in unit.lower():
+            return f"{int(value)} kJ"
+        elif unit == 'g':
+            return f"{value:.1f}g"
+        else:
+            return f"{value} {unit}" if unit else f"{value}"

ui/gradio_ui.py

@@ -0,0 +1,60 @@
+import gradio as gr
+from services.search_service import FoodSearchService
+
+
+class GradioUI:
+
+    def __init__(self):
+        self.food_service = FoodSearchService()
+
+    def search_products(self, query: str, max_results: int) -> str:
+        """
+        :param query:
+        :param max_results:
+        :return:
+        """
+        return self.food_service.search_products(query, max_results)
+
+    def create_interface(self):
+
+        with gr.Blocks(title="🤖 Healthify me", theme=gr.themes.Soft()) as demo:
+            # En-tête
+            gr.Markdown("""
+            # 🤖 Healthify me
+            """)
+
+            with gr.Row():
+                with gr.Column(scale=3):
+                    search_input = gr.Textbox(
+                        label="🔍 Search for product",
+                        placeholder="Ex: pepito, biscuits lu, pizza picard, yaourt danone..."
+                    )
+
+                with gr.Column(scale=1):
+                    max_results = gr.Slider(
+                        minimum=1,
+                        maximum=20,
+                        value=5,
+                        step=1,
+                        label="📊 Number of results",
+                        info="How many results ?"
+                    )
+
+            search_btn = gr.Button("🤖 Search", variant="primary", size="lg")
+
+            search_output = gr.Markdown()
+
+            search_btn.click(
+                self.search_products,
+                inputs=[search_input, max_results],
+                outputs=[search_output]
+            )
+
+            search_input.submit(
+                self.search_products,
+                inputs=[search_input, max_results],
+                outputs=[search_output]
+            )
+
+        return demo
+