rag

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir --timeout=200 --retries=5 -r requirements.txt
+
+COPY app.py .
+COPY ingest.py .
+COPY retriever.py .
+COPY french_brands.py .
+COPY data ./data
+
+EXPOSE 8000
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

add_prices.py

@@ -0,0 +1,51 @@
+from pathlib import Path
+
+import pandas as pd
+
+RAW_DIR = Path(__file__).parent.parent / "data" / "raw" / "skincare_products"
+CLEAN_DIR = Path(__file__).parent / "data"
+
+
+def add_prices():
+    # --- Dermstore: join on title to recover price + currency ---
+    clean = pd.read_csv(CLEAN_DIR / "dermstore_skincare_cleaned.csv")
+    if "price" not in clean.columns:
+        raw = pd.read_csv(RAW_DIR / "dermstore_data.csv", usecols=["title", "price", "currency"])
+        raw["title"] = raw["title"].str.strip()
+        raw = raw.drop_duplicates("title")
+        clean["title"] = clean["title"].str.strip()
+        clean = clean.merge(raw, on="title", how="left")
+        clean.to_csv(CLEAN_DIR / "dermstore_skincare_cleaned.csv", index=False)
+        print(f"Dermstore: {clean['price'].notna().sum()}/{len(clean)} produits avec prix")
+    else:
+        print("Dermstore: colonne price déjà présente, skip")
+
+    # --- LookFantastic: price existe mais format '£5.20', normaliser ---
+    clean = pd.read_csv(CLEAN_DIR / "lookfantastic_skincare_cleaned.csv")
+    if "currency" not in clean.columns:
+        clean["price"] = (
+            clean["price"]
+            .astype(str)
+            .str.replace("£", "", regex=False)
+            .str.strip()
+        )
+        clean["price"] = pd.to_numeric(clean["price"], errors="coerce")
+        clean["currency"] = "GBP"
+        clean.to_csv(CLEAN_DIR / "lookfantastic_skincare_cleaned.csv", index=False)
+        print(f"LookFantastic: {clean['price'].notna().sum()}/{len(clean)} produits avec prix")
+    else:
+        print("LookFantastic: colonne currency déjà présente, skip")
+
+    # --- Amazon: prix en INR, non fiables → null ---
+    clean = pd.read_csv(CLEAN_DIR / "amazon_skincare_cleaned.csv")
+    if "price" not in clean.columns:
+        clean["price"] = None
+        clean["currency"] = None
+        clean.to_csv(CLEAN_DIR / "amazon_skincare_cleaned.csv", index=False)
+        print(f"Amazon: {len(clean)} produits sans prix (INR source, non exploitable)")
+    else:
+        print("Amazon: colonne price déjà présente, skip")
+
+
+if __name__ == "__main__":
+    add_prices()

app.py

@@ -0,0 +1,68 @@
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import List, Optional
+
+import uvicorn
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+from ingest import CHROMA_DIR, build_index
+from retriever import recommend
+
+VALID_FORMULATIONS = {"vegan", "clean", "bio"}
+VALID_ORIGINS = {"french"}
+VALID_PRODUCT_TYPES = {
+    "moisturizer", "serum", "cleanser", "toner",
+    "mask", "oil", "sunscreen", "exfoliant", "eye_care",
+}
+VALID_PRICE_BANDS = {"budget", "mid", "premium", "any"}
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    if not CHROMA_DIR.exists() or not any(CHROMA_DIR.iterdir()):
+        build_index()
+    yield
+
+
+app = FastAPI(title="Product Recommendation API", lifespan=lifespan)
+
+
+class Preferences(BaseModel):
+    formulation: List[str] = []   # ex: ["vegan", "clean"]
+    origin: List[str] = []        # ex: ["french"]
+    product_type: Optional[str] = None  # ex: "serum"
+    price_band: Optional[str] = None    # "budget" | "mid" | "premium" | "any"
+
+
+class RecommendationInput(BaseModel):
+    skin_type: str  # "oily" | "dry" | "normal"
+    acne: bool
+    preferences: Preferences
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+@app.post("/recommend")
+def recommend_endpoint(payload: RecommendationInput):
+    prefs = payload.preferences.model_dump()
+
+    prefs["formulation"] = [f for f in prefs["formulation"] if f in VALID_FORMULATIONS]
+    prefs["origin"] = [o for o in prefs["origin"] if o in VALID_ORIGINS]
+    if prefs.get("product_type") not in VALID_PRODUCT_TYPES:
+        prefs["product_type"] = None
+    if prefs.get("price_band") not in VALID_PRICE_BANDS:
+        prefs["price_band"] = None
+
+    return recommend(
+        skin_type=payload.skin_type,
+        acne=payload.acne,
+        preferences=prefs,
+    )
+
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=8000, reload=False)

french_brands.py

@@ -0,0 +1,65 @@
+FRENCH_BRANDS = {
+    "vichy",
+    "la roche-posay",
+    "la roche posay",
+    "bioderma",
+    "avène",
+    "avene",
+    "eau thermale avène",
+    "eau thermale avene",
+    "caudalie",
+    "nuxe",
+    "clarins",
+    "lancôme",
+    "lancome",
+    "l'oréal",
+    "l'oreal",
+    "loreal",
+    "garnier",
+    "yves rocher",
+    "yves saint laurent",
+    "ysl beauté",
+    "institut esthederm",
+    "esthederm",
+    "sothys",
+    "filorga",
+    "embryolisse",
+    "lierac",
+    "liérac",
+    "roc",
+    "roger & gallet",
+    "sisley",
+    "givenchy",
+    "christian dior",
+    "dior",
+    "chanel",
+    "guerlain",
+    "payot",
+    "biotherm",
+    "mustela",
+    "galénic",
+    "galenic",
+    "phyto",
+    "kérastase",
+    "kerastase",
+    "decléor",
+    "decleor",
+    "svr",
+    "a-derma",
+    "aderma",
+    "ducray",
+    "klorane",
+    "rené furterer",
+    "rene furterer",
+    "nuxuriance",
+    "by terry",
+    "make up for ever",
+    "sephora collection",
+    "erborian",
+}
+
+
+def is_french(brand: str) -> bool:
+    if not brand or not isinstance(brand, str):
+        return False
+    return brand.lower().strip() in FRENCH_BRANDS

ingest.py

@@ -0,0 +1,236 @@
+from pathlib import Path
+
+import pandas as pd
+import chromadb
+from sentence_transformers import SentenceTransformer
+
+from french_brands import is_french
+
+CLEAN_DIR = Path(__file__).parent / "data"
+CHROMA_DIR = Path(__file__).parent / "chroma_db"
+COLLECTION_NAME = "skincare_products"
+
+USD_TO_EUR = 0.92
+GBP_TO_EUR = 1.17
+
+# Product type detection — ordered by specificity (most specific first)
+PRODUCT_TYPE_KEYWORDS = [
+    ("sunscreen",    ["spf", "sunscreen", "sun protection", "solaire", "solar"]),
+    ("eye_care",     ["eye cream", "eye serum", "eye gel", "contour des yeux", "eye care"]),
+    ("serum",        ["serum", "sérum", "essence", "ampoule", "concentrate"]),
+    ("oil",          ["face oil", "dry oil", "huile visage", "facial oil"]),
+    ("mask",         ["mask", "masque", "sheet mask"]),
+    ("exfoliant",    ["exfoliant", "scrub", "peel", "exfoliating", " aha ", " bha ", "acid toner"]),
+    ("cleanser",     ["cleanser", "cleansing", "face wash", "foaming", "micellar", "gel nettoyant", "mousse nettoyante"]),
+    ("toner",        ["toner", "toning lotion", "lotion tonique", "mist", "facial mist"]),
+    ("moisturizer",  ["moisturizer", "moisturiser", "cream", "crème", "lotion", "balm", "baume", "gel moistur"]),
+]
+
+NON_VEGAN = [
+    "beeswax", "cera alba", "lanolin", "carmine", "collagen", "elastin",
+    "gelatin", "gelatine", "honey", "mel ", "silk", "sericin",
+    "squalene", "tallow", "lard", "keratin", "casein", "chitosan",
+    "guanine", "shellac",
+]
+
+NON_CLEAN = [
+    "paraben", "sodium lauryl sulfate", "sodium laureth sulfate",
+    "dimethicone", "cyclopentasiloxane", "cyclohexasiloxane", "cyclomethicone",
+    "phthalate", "formaldehyde", "petrolatum", "mineral oil",
+    "polyethylene glycol", "peg-", "butylated hydroxytoluene", "bht",
+    "butylated hydroxyanisole", "bha ",
+]
+
+BIO_KEYWORDS = [
+    "organic", "bio ", "ecocert", "cosmos organic", "certifié bio",
+    "certified organic", "usda organic",
+]
+
+
+def _to_eur(price, currency: str) -> float | None:
+    try:
+        price = float(price)
+    except (TypeError, ValueError):
+        return None
+    if currency == "USD":
+        return round(price * USD_TO_EUR, 2)
+    if currency == "GBP":
+        return round(price * GBP_TO_EUR, 2)
+    return None
+
+
+def _price_band(price_eur: float | None) -> str:
+    if price_eur is None:
+        return "unknown"
+    if price_eur < 15:
+        return "budget"
+    if price_eur <= 50:
+        return "mid"
+    return "premium"
+
+
+def _normalize_type(raw_type: str, title: str = "") -> str:
+    text = f"{raw_type or ''} {title or ''}".lower()
+    for product_type, keywords in PRODUCT_TYPE_KEYWORDS:
+        if any(kw in text for kw in keywords):
+            return product_type
+    return "other"
+
+
+def _detect_vegan(ingredients: str, description: str = "") -> bool:
+    combined = f"{ingredients or ''} {description or ''}".lower()
+    if "vegan" in combined:
+        return True
+    if not ingredients:
+        return False
+    return not any(nv in ingredients.lower() for nv in NON_VEGAN)
+
+
+def _detect_clean(ingredients: str) -> bool:
+    if not ingredients:
+        return False
+    ingr = ingredients.lower()
+    return not any(nc in ingr for nc in NON_CLEAN)
+
+
+def _detect_bio(ingredients: str, description: str = "", title: str = "") -> bool:
+    text = f"{ingredients or ''} {description or ''} {title or ''}".lower()
+    return any(bk in text for bk in BIO_KEYWORDS)
+
+
+def _make_document(r: dict) -> str:
+    parts = []
+    type_label = r["product_type"].replace("_", " ")
+    parts.append(f"{type_label.title()} par {r['brand'] or 'marque inconnue'} : {r['name']}.")
+    if r["skin_type"]:
+        parts.append(f"Convient pour : {r['skin_type'][:120]}.")
+    if r["description"]:
+        parts.append(r["description"][:300])
+    if r["ingredients"]:
+        parts.append(f"Ingrédients : {r['ingredients'][:300]}.")
+    flags = []
+    if r["is_vegan"]:
+        flags.append("vegan")
+    if r["is_clean"]:
+        flags.append("clean")
+    if r["is_bio"]:
+        flags.append("bio")
+    if r["is_french"]:
+        flags.append("marque française")
+    if flags:
+        parts.append(f"Labels : {', '.join(flags)}.")
+    if r["price_eur"] is not None:
+        parts.append(f"Prix : {r['price_eur']}€.")
+    return " ".join(parts)
+
+
+def _load_amazon() -> list[dict]:
+    df = pd.read_csv(CLEAN_DIR / "amazon_skincare_cleaned.csv")
+    records = []
+    for _, row in df.iterrows():
+        records.append({
+            "name": str(row["Title"]).strip(),
+            "brand": str(row["Brand"]).strip(),
+            "product_type": _normalize_type(str(row["Product"]), str(row["Title"])),
+            "description": "",
+            "ingredients": "",
+            "skin_type": str(row.get("Skin_Type", "")).lower().strip(),
+            "price_eur": None,
+            "source": "amazon",
+        })
+    return records
+
+
+def _load_dermstore() -> list[dict]:
+    df = pd.read_csv(CLEAN_DIR / "dermstore_skincare_cleaned.csv")
+    records = []
+    for _, row in df.iterrows():
+        price_eur = _to_eur(row.get("price"), str(row.get("currency", "USD")))
+        records.append({
+            "name": str(row["title"]).strip(),
+            "brand": str(row["brand"]).strip(),
+            "product_type": _normalize_type("", str(row["title"])),
+            "description": str(row.get("description", ""))[:500],
+            "ingredients": str(row.get("ingredients", "")),
+            "skin_type": str(row.get("skin_type_and_concerns", "")).lower()[:200],
+            "price_eur": price_eur,
+            "source": "dermstore",
+        })
+    return records
+
+
+def _load_lookfantastic() -> list[dict]:
+    df = pd.read_csv(CLEAN_DIR / "lookfantastic_skincare_cleaned.csv")
+    records = []
+    for _, row in df.iterrows():
+        price_eur = _to_eur(row.get("price"), "GBP")
+        records.append({
+            "name": str(row["product_name"]).strip(),
+            "brand": "",
+            "product_type": _normalize_type(str(row.get("product_type", "")), str(row["product_name"])),
+            "description": "",
+            "ingredients": str(row.get("ingredients", "")),
+            "skin_type": "",
+            "price_eur": price_eur,
+            "source": "lookfantastic",
+        })
+    return records
+
+
+def build_index():
+    print("Chargement des produits...")
+    records = _load_amazon() + _load_dermstore() + _load_lookfantastic()
+    print(f"{len(records)} produits chargés")
+
+    for r in records:
+        r["is_vegan"] = _detect_vegan(r["ingredients"], r["description"])
+        r["is_clean"] = _detect_clean(r["ingredients"])
+        r["is_bio"] = _detect_bio(r["ingredients"], r["description"], r["name"])
+        r["is_french"] = is_french(r["brand"])
+        r["price_band"] = _price_band(r["price_eur"])
+
+    documents = [_make_document(r) for r in records]
+    ids = [f"product_{i}" for i in range(len(records))]
+
+    metadatas = [
+        {
+            "name": r["name"],
+            "brand": r["brand"] or "",
+            "product_type": r["product_type"],
+            "price_eur": float(r["price_eur"]) if r["price_eur"] is not None else -1.0,
+            "price_band": r["price_band"],
+            "source": r["source"],
+            "is_vegan": r["is_vegan"],
+            "is_clean": r["is_clean"],
+            "is_bio": r["is_bio"],
+            "is_french": r["is_french"],
+        }
+        for r in records
+    ]
+
+    print("Génération des embeddings...", flush=True)
+    model = SentenceTransformer("all-MiniLM-L6-v2")
+    embeddings = model.encode(documents, show_progress_bar=True).tolist()
+
+    print("Stockage dans ChromaDB...")
+    client = chromadb.PersistentClient(path=str(CHROMA_DIR))
+    try:
+        client.delete_collection(COLLECTION_NAME)
+    except Exception:
+        pass
+    collection = client.create_collection(COLLECTION_NAME)
+
+    batch_size = 500
+    for i in range(0, len(records), batch_size):
+        collection.add(
+            documents=documents[i : i + batch_size],
+            embeddings=embeddings[i : i + batch_size],
+            metadatas=metadatas[i : i + batch_size],
+            ids=ids[i : i + batch_size],
+        )
+
+    print(f"Index construit : {len(records)} produits indexés dans {CHROMA_DIR}")
+
+
+if __name__ == "__main__":
+    build_index()

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn[standard]
+pandas
+pydantic
+sentence-transformers
+chromadb
+groq

retriever.py

@@ -0,0 +1,323 @@
+import os
+from pathlib import Path
+from typing import Optional
+
+import chromadb
+from groq import Groq
+from sentence_transformers import SentenceTransformer
+
+CHROMA_DIR = Path(__file__).parent / "chroma_db"
+COLLECTION_NAME = "skincare_products"
+
+_model: Optional[SentenceTransformer] = None
+_collection = None
+
+ROUTINE_STEPS = {
+    "matin": ["cleanser", "toner", "serum", "moisturizer"],
+    "soir":  ["cleanser", "serum", "moisturizer"],
+}
+SKIN_RULES = {
+    "oily": {
+        "avoid": ["oil", "heavy", "comedogenic"],
+        "prefer": ["oil-free", "non-comedogenic", "light", "gel"],
+    },
+    "dry": {
+        "avoid": ["alcohol"],
+        "prefer": ["hydrating", "ceramides", "rich"],
+    }
+}
+
+def _get_model() -> SentenceTransformer:
+    global _model
+    if _model is None:
+        _model = SentenceTransformer("all-MiniLM-L6-v2")
+    return _model
+
+
+def _get_collection():
+    global _collection
+    if _collection is None:
+        client = chromadb.PersistentClient(path=str(CHROMA_DIR))
+        _collection = client.get_collection(COLLECTION_NAME)
+    return _collection
+
+
+def _build_query(skin_type: str, acne: bool, preferences: dict) -> str:
+    parts = [f"skincare product for {skin_type} skin"]
+    if acne:
+        parts.append("acne-prone")
+    if pt := preferences.get("product_type"):
+        parts.append(pt)
+    for f in preferences.get("formulation", []):
+        parts.append(f)
+    if "french" in preferences.get("origin", []):
+        parts.append("French brand")
+    return ", ".join(parts)
+
+
+def _build_where(preferences: dict) -> Optional[dict]:
+    conditions = []
+    for flag, key in [("vegan", "is_vegan"), ("clean", "is_clean"), ("bio", "is_bio")]:
+        if flag in preferences.get("formulation", []):
+            conditions.append({key: {"$eq": True}})
+    if "french" in preferences.get("origin", []):
+        conditions.append({"is_french": {"$eq": True}})
+    if (pb := preferences.get("price_band")) and pb not in ("any", None):
+        conditions.append({"price_band": {"$eq": pb}})
+    if not conditions:
+        return None
+    if len(conditions) == 1:
+        return conditions[0]
+    return {"$and": conditions}
+
+
+def _query(query_text: str, where: Optional[dict], n_results: int = 5) -> dict:
+    collection = _get_collection()
+    model      = _get_model()  # ← ton SentenceTransformer, enfin utilisé
+
+    embedding = model.encode(query_text).tolist()  # même modèle qu'ingest.py
+
+    try:
+        kwargs: dict = {
+            "query_embeddings": [embedding],  # ← vecteur, plus query_texts
+            "n_results": n_results,
+        }
+        if where:
+            kwargs["where"] = where
+        return collection.query(**kwargs)
+    except Exception:
+        return {"ids": [[]], "documents": [[]], "metadatas": [[]]}
+    
+
+def _generate_explanation(product_doc: str, skin_type: str, acne: bool, preferences: dict) -> str:
+    prefs = []
+    for f in preferences.get("formulation", []):
+        prefs.append(f)
+    if "french" in preferences.get("origin", []):
+        prefs.append("marque française")
+    if pt := preferences.get("product_type"):
+        prefs.append(f"type : {pt}")
+    if pb := preferences.get("price_band"):
+        prefs.append(f"budget : {pb}")
+
+    profile = f"peau {skin_type}"
+    if acne:
+        profile += ", tendance acnéique"
+    if prefs:
+        profile += f", préférences : {', '.join(prefs)}"
+
+    client = Groq(api_key=os.environ["GROQ_API_KEY"])
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    "Tu es un expert en soins de la peau. "
+                    "En 2 à 3 phrases courtes en français, explique pourquoi ce produit "
+                    "est adapté au profil de l'utilisateur. Sois précis et bienveillant. "
+                ),
+            },
+            {
+                "role": "user",
+                "content": f"Profil : {profile}\n\nProduit : {product_doc}",
+            },
+        ],
+        max_tokens=350,
+    )
+    return response.choices[0].message.content
+
+def routine_with_llm(routine: dict, skin_type: str, acne: bool) -> str:
+    import os
+    from groq import Groq
+
+    client = Groq(api_key=os.environ["GROQ_API_KEY"])
+
+    # 1. FIX: On boucle sur la 'routine' envoyée, pas sur le dictionnaire brut ROUTINE_STEPS
+    routine_text = ""
+    for moment, steps in routine.items():
+        routine_text += f"\n{moment.upper()}:\n"
+        for step in steps:
+            if step["product_name"]:
+                routine_text += f"- {step['etape']}: {step['product_name']} ({step['brand']})\n"
+            else:
+                routine_text += f"- {step['etape']}: Aucun produit\n"
+
+    profile = f"peau {skin_type}"
+    if acne:
+        profile += ", tendance acnéique"
+
+    response = client.chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        messages=[
+            {
+                "role": "system",
+                "content": (
+                    "Tu es un influenceur beauté expert en skincare. "
+                    "Propose ta routine skincare en suivant la routine skincare qui t'a été fournie. "
+                    "1. Verifie que le produit recommandé est adapté et si c'est le cas propose le dans ta routine"
+                    "2. Propose un produit adapte au resultat du type de peau. "
+                    "3. Explique avec enthousiasme et brievement le rôle de chaque produit. "
+                    "Réponds en français avec un ton chaleureux. "
+                    "CRUCIAL : Tu dois ABSOLUMENT utiliser la syntaxe Markdown suivante pour structurer ta réponse.\n\n"
+                    "Format OBLIGATOIRE:\n"
+                    "Coucou ! Voici ta routine sur-mesure ✨ :\n\n"
+                    "### 🌞 Matin\n"
+                    "- **[product_type]** :[Nom du produit] [Ton explication...]\n\n"
+                    "### 🌙 Soir\n"
+                    "- **[product_type]** : [Nom du produit][Ton explication...]\n"
+                    "J'espère que cette routine te conviendra 😎!"
+                ),
+            },
+            {
+                "role": "user",
+                "content": f"Profil: {profile}\n\nRoutine exacte à présenter:\n{routine_text}",
+            },
+        ],
+        max_tokens=550,
+    )
+
+    return response.choices[0].message.content
+
+
+def is_compatible(meta: dict, skin_type: str) -> bool:
+    """Vérifie que le produit ne contient pas d'ingrédients déconseillés."""
+    rules = SKIN_RULES.get(skin_type, {})
+    name  = meta.get("name", "").lower()
+    return not any(word in name for word in rules.get("avoid", []))
+
+
+# 2. FIX: Il FAUT garder cette fonction dé-commentée, c'est elle qui interroge ChromaDB !
+def _build_routine_steps(
+    skin_type: str,
+    acne: bool,
+    main_product: dict,
+    preferences: dict
+) -> dict:
+
+    routine = {}
+
+    for moment, steps in ROUTINE_STEPS.items():
+        routine[moment] = []
+
+        for step in steps:
+            # Produit principal = on prend direct
+            if main_product.get("product_type") == step:
+                routine[moment].append({
+                    "etape":         step,
+                    "product_name":  main_product["product_name"],
+                    "brand":         main_product["brand"],
+                    "price_display": main_product["price_display"],
+                    "is_vegan":      main_product["is_vegan"],
+                    "is_clean":      main_product["is_clean"],
+                    "is_main":       True,
+                })
+                continue
+
+            # Sinon -> chercher un produit
+            query = f"{step} pour peau {skin_type}"
+            if acne and step in ("serum", "cleanser", "exfoliant"):
+                query += " acnéique"
+
+            if skin_type == "oily" and step == "serum":
+                query += " oil-free serum gel"
+            if skin_type == "oily" and step == "moisturizer":
+                query += " lightweight oil-free gel moisturizer"
+            if step == "toner":
+                query += " toner astringent niacinamide"
+            if step == "exfoliant":
+                if acne:
+                    query += " salicylic acid bha exfoliant" 
+
+            where = {"product_type": {"$eq": step}}
+            
+            results = _query(query, where, n_results=5)
+
+            if results["ids"][0]:
+                candidates = results["metadatas"][0]
+                chosen = None
+                for m in candidates:
+                    if is_compatible(m, skin_type):
+                        chosen = m
+                        break
+
+                if not chosen:
+                    chosen = candidates[0]
+                    
+                routine[moment].append({
+                    "etape":         step,
+                    "product_name":  chosen["name"],
+                    "brand":         chosen["brand"],
+                    "price_display": f"{chosen['price_eur']}€" if chosen["price_eur"] > 0 else "",
+                    "is_vegan":      chosen["is_vegan"],
+                    "is_clean":      chosen["is_clean"],
+                    "is_main":       False,
+                })
+            else:
+                routine[moment].append({
+                    "etape":         step,
+                    "product_name":  None,
+                    "brand":         None,
+                    "is_main":       False,
+                })
+
+    return routine
+
+
+def recommend(skin_type: str, acne: bool, preferences: dict) -> dict:
+    query_text = _build_query(skin_type, acne, preferences)
+    where      = _build_where(preferences)
+
+    results = _query(query_text, where, n_results=5)
+
+    if not results["ids"][0] and where:
+        results = _query(query_text, None, n_results=5)
+
+    if not results["ids"][0]:
+        results = _query(query_text, None, n_results=5)
+
+    if not results["ids"][0]:
+        return {"error": "Aucun produit trouvé"}
+
+    meta = results["metadatas"][0][0]
+    doc  = results["documents"][0][0]
+
+    main_product_dict = {
+        "product_name":  meta["name"],
+        "brand":         meta["brand"],
+        "product_type":  meta["product_type"],
+        "price_display": f"{meta['price_eur']}€" if meta["price_eur"] > 0 else "",
+        "is_vegan":      meta["is_vegan"],
+        "is_clean":      meta["is_clean"],
+    }
+
+    # 3. FIX: On dé-commente la création de la routine !
+    routine_complete = _build_routine_steps(skin_type, acne, main_product_dict, preferences)
+    
+    # 4. FIX: On passe bien `routine_complete` à l'influenceur LLM
+    validated_routine = routine_with_llm(
+        routine=routine_complete,
+        skin_type=skin_type,
+        acne=acne
+    )
+
+    explanation = _generate_explanation(
+        doc,
+        skin_type,
+        acne,
+        preferences
+    )
+    
+    return {
+        "product_name":  meta["name"],
+        "brand":         meta["brand"],
+        "product_type":  meta["product_type"],
+        "price_display": f"{meta['price_eur']}€" if meta["price_eur"] > 0 else "",
+        "source":        meta["source"],
+        "is_french":     meta["is_french"],
+        "is_vegan":      meta["is_vegan"],
+        "is_clean":      meta["is_clean"],
+        "explanation":   explanation,
+        "routine":       routine_complete,
+        "routine_validated": validated_routine
+    }