Upload 39 files

backend/.gitignore

@@ -0,0 +1,29 @@
+# Secrets & Env
+.env
+*.env.local
+.env.*.local
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+
+# Node
+node_modules/
+frontend/dist/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+
+# Docker
+.docker/

backend/app/config.py

@@ -0,0 +1,31 @@
+from pydantic_settings import BaseSettings
+from typing import Optional, List
+
+class Settings(BaseSettings):
+    APP_NAME: str = "scanleni-pro"
+    API_PREFIX: str = "/api/v1"
+    SECRET_KEY: str = "change-in-production-use-openssl-rand-hex-32"
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 60
+    
+    OCR_CONFIDENCE_THRESHOLD: float = 0.45
+    OCR_MAX_DIM: int = 1500
+    
+    LLM_PROVIDER: str = "openai"  # openai | gemini | claude | local
+    LLM_API_KEY: Optional[str] = None
+    LLM_BASE_URL: Optional[str] = None
+    LLM_MODEL: str = "gpt-4o-mini"
+    EMBEDDING_MODEL: str = "all-MiniLM-L6-v2"
+    VECTOR_TOP_K: int = 4
+    
+    DATABASE_URL: str = "postgresql://postgres:postgres@localhost:5432/scanleni"
+    REDIS_URL: str = "redis://localhost:6379/0"
+    
+    RATE_LIMIT_REQUESTS: int = 30
+    RATE_LIMIT_WINDOW: int = 60
+
+    class Config:
+        env_file = ".env"
+        case_sensitive = True
+
+settings = Settings()

backend/app/core/websocket_handler.py

@@ -0,0 +1,68 @@
+import asyncio
+import time
+from fastapi import WebSocket
+from app.services.ocr_service import ocr_service
+from app.services.predictive_engine import track_exposure, get_user_trends
+from app.services.graph_store import graph_store
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ScanWebSocketManager:
+    def __init__(self):
+        self.active_connections: dict[str, WebSocket] = {}
+        self.debounce_seconds = 1.2
+        self.last_scan_time: dict[str, float] = {}
+
+    async def connect(self, websocket: WebSocket, user_id: str):
+        await websocket.accept()
+        self.active_connections[user_id] = websocket
+        logger.info("WS connected: %s", user_id)
+
+    def disconnect(self, user_id: str):
+        self.active_connections.pop(user_id, None)
+        self.last_scan_time.pop(user_id, None)
+        logger.info("WS disconnected: %s", user_id)
+
+    async def send_json(self, user_id: str, data: dict):
+        if ws := self.active_connections.get(user_id):
+            try:
+                await ws.send_json(data)
+            except Exception:
+                self.disconnect(user_id)
+
+    async def process_frame(self, user_id: str, image_bytes: bytes, profile: dict):
+        now = time.time()
+        last = self.last_scan_time.get(user_id, 0)
+        if now - last < self.debounce_seconds:
+            return
+
+        self.last_scan_time[user_id] = now
+        try:
+            ocr_data = ocr_service.extract(image_bytes)
+            harmful_count = sum(1 for b in ocr_data if b.is_harmful)
+            health_score = max(0, 100 - (harmful_count * 12))
+
+            # Predictive & Graph enrichment
+            track_exposure(user_id, ocr_data)
+            trends = get_user_trends(user_id)
+            graph_insights = {}
+            for b in ocr_data:
+                if b.is_harmful:
+                    related = graph_store.get_related(b.text.lower().replace(" ", "_"), depth=1)
+                    if related:
+                        graph_insights[b.text] = related
+
+            await self.send_json(user_id, {
+                "type": "scan_update",
+                "ocr_data": [b.model_dump() for b in ocr_data],
+                "health_score": health_score,
+                "trends": trends,
+                "graph_insights": graph_insights,
+                "timestamp": now
+            })
+        except Exception as e:
+            logger.error("WS OCR failed for %s: %s", user_id, e)
+            await self.send_json(user_id, {"type": "error", "message": "Processing failed. Hold steady."})
+
+ws_manager = ScanWebSocketManager()

backend/app/main.py

@@ -0,0 +1,17 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.routers import scan, chat
+from app.config import settings
+import logging
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+
+app = FastAPI(title=settings.APP_NAME, version="1.0.0")
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
+
+app.include_router(scan.router, prefix=settings.API_PREFIX)
+app.include_router(chat.router, prefix=settings.API_PREFIX)
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "service": settings.APP_NAME}

backend/app/models/schemas.py

@@ -0,0 +1,65 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+from datetime import datetime
+
+class BBox(BaseModel):
+    points: List[List[float]]
+
+class TextBlock(BaseModel):
+    text: str
+    confidence: float = Field(..., ge=0.0, le=1.0)
+    bbox: BBox
+    is_harmful: bool = False
+    harm_reason: Optional[str] = None
+    category: Optional[str] = None
+
+class RiskAnalysis(BaseModel):
+    health_score: int = Field(..., ge=0, le=100)
+    risk_level: str
+    flagged_ingredients: List[str] = []
+    allergens_detected: List[str] = []
+    ultra_processed_score: float = Field(..., ge=0.0, le=1.0)
+    summary: str
+
+class Recommendation(BaseModel):
+    product_name: str
+    reason: str
+    match_score: float
+    image_url: Optional[str] = None
+    category: str
+
+class GamificationState(BaseModel):
+    streak_days: int = 0
+    points: int = 0
+    badges: List[str] = []
+    level: int = 1
+    next_level_points: int = 100
+
+class UserProfile(BaseModel):
+    user_id: str = "anonymous"
+    allergies: List[str] = []
+    conditions: List[str] = []
+    dietary: List[str] = []
+    skin_type: Optional[str] = None
+
+class ARScanResponse(BaseModel):
+    status: str
+    ocr_data: List[TextBlock] = []
+    risk_analysis: RiskAnalysis
+    recommendations: List[Recommendation] = []
+    gamification: GamificationState
+    ai_summary: str
+    timestamp: datetime = Field(default_factory=datetime.utcnow)
+
+class ChatRequest(BaseModel):
+    message: str
+    context_product: Optional[str] = None
+    conversation_id: Optional[str] = None
+    user_profile: Optional[UserProfile] = None
+
+class ChatResponse(BaseModel):
+    conversation_id: str
+    reply: str
+    sources: List[str] = []
+    confidence: float = 0.0
+    timestamp: datetime = Field(default_factory=datetime.utcnow)

backend/app/routers/agent.py

@@ -0,0 +1,33 @@
+from fastapi import APIRouter
+from app.models.schemas import ChatRequest, ChatResponse
+from app.services.rag_service import rag_service
+import json
+
+router = APIRouter(prefix="/agent", tags=["AI Agent"])
+
+@router.post("/", response_model=ChatResponse)
+async def run_agent(req: ChatRequest):
+    intent_prompt = f"""Classify this request into one category ONLY:
+    - skincare_routine
+    - product_comparison
+    - health_analysis
+    - general_qa
+    Request: "{req.message}"
+    Return ONLY the category name."""
+    
+    intent_resp = await rag_service.llm.generate([{"role": "system", "content": intent_prompt}])
+    category = intent_resp.strip().lower()
+
+    if "comparison" in category:
+        steps = "1. Identify products\n2. Fetch profiles\n3. Calculate diff scores\n4. Output recommendation"
+    elif "routine" in category:
+        steps = "1. Identify skin type/budget\n2. Match products to profile\n3. Order steps (cleanse→treat→moisturize)\n4. Add warnings"
+    elif "health" in category:
+        steps = "1. Scan history analysis\n2. Exposure trend check\n3. Predict risk\n4. Suggest intervention"
+    else:
+        steps = "1. Retrieve safety context\n2. Personalize to profile\n3. Generate structured answer\n4. Provide next steps"
+
+    plan_msg = f"Agent Plan ({category}): [{steps}]\nExecute step-by-step and output final recommendation."
+    req.message = f"{req.message}\n\n{plan_msg}"
+    
+    return await rag_service.chat(req)

backend/app/routers/chat.py

@@ -0,0 +1,17 @@
+from fastapi import APIRouter, HTTPException
+from app.services.rag_service import rag_service
+from app.models.schemas import ChatRequest, ChatResponse
+import logging
+
+logger = logging.getLogger(__name__)
+router = APIRouter(prefix="/chat", tags=["AI Assistant"])
+
+@router.post("/", response_model=ChatResponse)
+async def chat_with_ai(req: ChatRequest):
+    try:
+        logger.info("Chat request: conv_id=%s, msg=%s", req.conversation_id, req.message[:50])
+        response = await rag_service.chat(req)
+        return response
+    except Exception as e:
+        logger.error("Chat endpoint failed: %s", e)
+        raise HTTPException(status_code=500, detail="AI chat service failed. Please try again.")

backend/app/routers/scan.py

@@ -0,0 +1,76 @@
+from fastapi import APIRouter, File, UploadFile, HTTPException, Query
+from app.services.ocr_service import ocr_service
+from app.services.gamification_service import calculate_gamification
+from app.services.recommendation_service import find_alternatives
+from app.models.schemas import ARScanResponse, RiskAnalysis, GamificationState
+import logging
+
+router = APIRouter(prefix="/scan", tags=["Scanning"])
+logger = logging.getLogger(__name__)
+
+# Lightweight fallback keywords for immediate flagging.
+# The AI/RAG engine will replace this with dynamic, profile-aware analysis in Phase 3.
+HARMFUL_KEYWORDS = [
+    "paraben", "sulfate", "phthalate", "formaldehyde", "fragrance", "parfum",
+    "high fructose corn syrup", "red 40", "yellow 5", "sodium benzoate", "msg",
+    "alcohol denat", "mineral oil", "retinol"
+]
+
+@router.post("/", response_model=ARScanResponse)
+async def scan_product(file: UploadFile = File(...), conditions: str = Query(default="")):
+    logger.info("Scan request received: %s", file.filename)
+    contents = await file.read()
+
+    # 1. Run OCR Pipeline
+    try:
+        ocr_data = ocr_service.extract(contents)
+    except Exception as e:
+        logger.error("OCR processing failed: %s", str(e))
+        raise HTTPException(status_code=500, detail="OCR processing failed. Please try a clearer image.")
+
+    if not ocr_data:
+        raise HTTPException(status_code=400, detail="No text detected in the uploaded image.")
+
+    # 2. Flag harmful ingredients & attach reasons
+    flagged = []
+    for block in ocr_data:
+        text_lower = block.text.lower()
+        if any(keyword in text_lower for keyword in HARMFUL_KEYWORDS):
+            block.is_harmful = True
+            block.harm_reason = "Contains potentially harmful or controversial ingredient."
+            flagged.append(block.text)
+
+    # 3. Calculate health score & risk level
+    health_score = max(0, 100 - (len(flagged) * 15))
+    if health_score > 80:
+        risk_level = "SAFE"
+    elif health_score > 50:
+        risk_level = "MODERATE"
+    else:
+        risk_level = "HIGH"
+
+    # 4. Build RiskAnalysis (ALL required schema fields included)
+    risk = RiskAnalysis(
+        health_score=health_score,
+        risk_level=risk_level,
+        flagged_ingredients=flagged,
+        allergens_detected=[],          # Required by schema. AI engine will populate later.
+        ultra_processed_score=0.0,      # Required by schema. AI engine will calculate later.
+        summary=f"Detected {len(flagged)} flagged ingredients. Health score: {health_score}/100."
+    )
+
+    # 5. Run Gamification & Recommendation Engines
+    gamification = calculate_gamification(risk, GamificationState())
+    recommendations = find_alternatives(risk)
+
+    logger.info("Scan complete. Risk: %s, Score: %d, Flagged: %d", risk_level, health_score, len(flagged))
+
+    # 6. Return unified AR-ready payload
+    return ARScanResponse(
+        status="success",
+        ocr_data=ocr_data,
+        risk_analysis=risk,
+        recommendations=recommendations,
+        gamification=gamification,
+        ai_summary=risk.summary
+    )

backend/app/services/gamification_service.py

@@ -0,0 +1,22 @@
+from app.models.schemas import RiskAnalysis, GamificationState
+
+def calculate_gamification(risk: RiskAnalysis, current_state: GamificationState) -> GamificationState:
+    points = 10
+    if risk.risk_level == "HIGH":
+        points += 5
+    elif risk.risk_level == "SAFE":
+        points += 15
+
+    current_state.points += points
+    current_state.streak_days += 1
+    current_state.level = max(1, current_state.points // 100 + 1)
+    current_state.next_level_points = (current_state.level * 100) - current_state.points
+
+    if risk.health_score >= 90 and "Clean Choice" not in current_state.badges:
+        current_state.badges.append("Clean Choice")
+    if current_state.streak_days >= 7 and "Weekly Warrior" not in current_state.badges:
+        current_state.badges.append("Weekly Warrior")
+    if current_state.points >= 500 and "Ingredient Detective" not in current_state.badges:
+        current_state.badges.append("Ingredient Detective")
+
+    return current_state

backend/app/services/graph_store.py

@@ -0,0 +1,62 @@
+import networkx as nx
+import json
+from pathlib import Path
+from typing import Dict, Any
+
+GRAPH_PATH = Path(__file__).parent.parent.parent / "data" / "ingredient_graph.json"
+
+class IngredientGraph:
+    def __init__(self):
+        self.graph = nx.DiGraph()
+        self._load_or_init()
+
+    def _load_or_init(self):
+        if GRAPH_PATH.exists():
+            data = json.loads(GRAPH_PATH.read_text())
+            for node, attrs in data.get("nodes", {}).items():
+                self.graph.add_node(node, **attrs)
+            for u, v, attrs in data.get("edges", []):
+                self.graph.add_edge(u, v, **attrs)
+        else:
+            self._build_default()
+            self.save()
+
+    def _build_default(self):
+        ingredients = {
+            "parabens": {"category": "preservative", "risk": "high", "effects": ["endocrine_disruption", "skin_irritation"]},
+            "retinol": {"category": "active", "risk": "moderate", "effects": ["photosensitivity", "anti_aging"]},
+            "fragrance": {"category": "additive", "risk": "moderate", "effects": ["allergen", "respiratory_irritation"]},
+            "niacinamide": {"category": "active", "risk": "low", "effects": ["barrier_repair", "anti_inflammatory"]},
+            "sodium_lauryl_sulfate": {"category": "surfactant", "risk": "moderate", "effects": ["barrier_stripping", "acne_trigger"]},
+            "alcohol_denat": {"category": "solvent", "risk": "moderate", "effects": ["drying", "barrier_disruption"]},
+            "mineral_oil": {"category": "emollient", "risk": "moderate", "effects": ["comedogenic", "occlusive"]}
+        }
+        for ing, meta in ingredients.items():
+            self.graph.add_node(ing, **meta)
+            for effect in meta["effects"]:
+                self.graph.add_edge(ing, effect, relation="causes")
+
+    def save(self):
+        data = {
+            "nodes": {n: dict(self.graph.nodes[n]) for n in self.graph.nodes()},
+            "edges": [(u, v, dict(d)) for u, v, d in self.graph.edges(data=True)]
+        }
+        GRAPH_PATH.parent.mkdir(parents=True, exist_ok=True)
+        GRAPH_PATH.write_text(json.dumps(data, indent=2))
+
+    def get_related(self, ingredient: str, depth: int = 2) -> Dict[str, Any]:
+        normalized = ingredient.lower().replace(" ", "_")
+        if normalized not in self.graph:
+            return {}
+        sub = nx.ego_graph(self.graph, normalized, radius=depth)
+        return {n: dict(sub.nodes[n]) for n in sub.nodes()}
+
+    def query_effects(self, effects: list[str]) -> Dict[str, Any]:
+        matches = {}
+        for ing in self.graph.nodes():
+            ing_effects = self.graph.nodes[ing].get("effects", [])
+            if any(e in ing_effects for e in effects):
+                matches[ing] = self.graph.nodes[ing]
+        return matches
+
+graph_store = IngredientGraph()

backend/app/services/ocr_service.py

@@ -0,0 +1,66 @@
+import cv2
+import numpy as np
+from PIL import Image, ImageEnhance, ImageFilter
+import io
+from rapidocr_onnxruntime import RapidOCR
+from app.models.schemas import TextBlock, BBox
+from app.config import settings
+import re
+
+class OCRService:
+    def __init__(self):
+        # Optimized for product labels: angle classification, higher det limit, batch processing
+        self.engine = RapidOCR(
+            use_angle_cls=True,
+            det_limit_side_len=1500,
+            rec_batch_num=6,
+            print_verbose=False
+        )
+        self.threshold = settings.OCR_CONFIDENCE_THRESHOLD
+
+    def _enhance_image(self, img: Image.Image) -> Image.Image:
+        """Product label optimization: sharpen, boost contrast, reduce color noise"""
+        img = img.filter(ImageFilter.SHARPEN)
+        img = ImageEnhance.Contrast(img).enhance(1.4)
+        img = ImageEnhance.Color(img).enhance(0.7)  # Slight desaturation helps text pop
+        return img
+
+    def _clean_text(self, text: str) -> str:
+        """Fix OCR fragmentation, remove noise, merge broken words"""
+        text = re.sub(r'[^a-zA-Z0-9\s,./()-]', '', text)
+        text = re.sub(r'\s+', ' ', text).strip()
+        # Drop single-character noise unless it's a known initial (e.g., "E", "U")
+        if len(text) <= 1 and text.upper() not in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
+            return ""
+        return text
+
+    def extract(self, image_bytes: bytes) -> list[TextBlock]:
+        img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
+        img = self._enhance_image(img)
+
+        if max(img.size) > settings.OCR_MAX_DIM:
+            img.thumbnail((settings.OCR_MAX_DIM, settings.OCR_MAX_DIM))
+
+        result, _ = self.engine(np.array(img))
+        blocks = []
+        if result:
+            for box, text, conf in result:
+                cleaned = self._clean_text(text)
+                if conf >= self.threshold and len(cleaned) > 1:
+                    blocks.append(TextBlock(
+                        text=cleaned,
+                        confidence=float(conf),
+                        bbox=BBox(points=box),
+                        category=self._classify(cleaned)
+                    ))
+        return blocks
+
+    def _classify(self, text: str) -> str:
+        t = text.lower()
+        if any(k in t for k in ["water", "aqua", "glycerin", "oil", "corn", "sugar", "flour"]): return "base"
+        if any(k in t for k in ["paraben", "sulfate", "phthalate", "benzoate"]): return "preservative"
+        if any(k in t for k in ["fragrance", "parfum", "aroma"]): return "fragrance"
+        if any(k in t for k in ["vitamin", "niacinamide", "retinol", "zinc"]): return "active"
+        return "other"
+
+ocr_service = OCRService()

backend/app/services/predictive_engine.py

@@ -0,0 +1,72 @@
+import time
+import json
+from collections import defaultdict
+from typing import Dict, List, Any
+from redis import Redis
+from app.config import settings
+
+# Fallback to in-memory dict if Redis is unavailable (dev mode)
+redis = Redis.from_url(settings.REDIS_URL, decode_responses=True) if hasattr(settings, "REDIS_URL") else None
+in_memory_store: Dict[str, List[Dict]] = defaultdict(list)
+in_memory_exposures: Dict[str, Dict] = defaultdict(lambda: defaultdict(int))
+
+def track_exposure(user_id: str, ocr_data: list):
+    now = int(time.time())
+    flagged = [b.text.lower().replace(" ", "_") for b in ocr_data if b.is_harmful]
+    
+    if redis:
+        key = f"user:{user_id}:scans"
+        redis.rpush(key, json.dumps({"ts": now, "flagged": len(flagged)}))
+        redis.expire(key, 60*60*24*90)
+        for ing in flagged:
+            exp_key = f"user:{user_id}:exposure:{ing}"
+            redis.hincrby(exp_key, "count", 1)
+            redis.hset(exp_key, "last_seen", now)
+    else:
+        in_memory_store[user_id].append({"ts": now, "flagged": len(flagged)})
+        if len(in_memory_store[user_id]) > 100:
+            in_memory_store[user_id] = in_memory_store[user_id][-100:]
+        for ing in flagged:
+            in_memory_exposures[user_id][ing] += 1
+
+def get_user_trends(user_id: str) -> Dict[str, Any]:
+    scans = []
+    exposures = {}
+    
+    if redis:
+        scan_key = f"user:{user_id}:scans"
+        scans_raw = redis.lrange(scan_key, 0, 29)
+        scans = [json.loads(s) for s in scans_raw]
+        exp_keys = redis.keys(f"user:{user_id}:exposure:*")
+        for key in exp_keys:
+            name = key.split(":")[-1]
+            count = int(redis.hget(key, "count") or 0)
+            if count > 0:
+                exposures[name] = count
+    else:
+        scans = in_memory_store.get(user_id, [])
+        exposures = dict(in_memory_exposures.get(user_id, {}))
+
+    if not scans:
+        return {"avg_flagged": 0, "trend": "stable", "top_exposures": [], "insight": "Scan more products to build your health baseline."}
+
+    flagged_counts = [s["flagged"] for s in scans]
+    avg = sum(flagged_counts) / len(flagged_counts)
+    recent = flagged_counts[-5:]
+    older = flagged_counts[:5] if len(flagged_counts) > 5 else []
+    trend = "improving" if len(recent) > 0 and len(older) > 0 and sum(recent) < sum(older) else "stable"
+
+    top_exp = sorted(exposures.items(), key=lambda x: x[1], reverse=True)[:3]
+    insight = f"Average flagged: {avg:.1f}/scan. "
+    if trend == "improving":
+        insight += "Your choices are getting cleaner."
+    elif top_exp:
+        insight += f"Frequent exposure: {', '.join(t[0].replace('_', ' ') for t in top_exp)}."
+
+    return {
+        "avg_flagged": round(avg, 1),
+        "trend": trend,
+        "top_exposures": [{"ingredient": k.replace('_', ' '), "count": v} for k, v in top_exp],
+        "insight": insight,
+        "scan_count": len(scans)
+    }

backend/app/services/rag_service.py

@@ -0,0 +1,102 @@
+import httpx
+import uuid
+import logging
+from typing import List, Optional, Dict
+from app.models.schemas import ChatRequest, ChatResponse
+from app.services.vector_store import vector_store
+from app.config import settings
+
+logger = logging.getLogger(__name__)
+
+class LLMClient:
+    def __init__(self, provider: str, api_key: Optional[str], base_url: str, model: str):
+        self.provider = provider
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+        self.timeout = 30.0
+
+    async def generate(self, messages: List[Dict[str, str]]) -> str:
+        if not self.api_key or not self.api_key.startswith("gsk_"):
+            return "⚠️ AI service not configured. Please add a valid Groq API key to your .env file."
+
+        headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+        payload = {"model": self.model, "messages": messages, "temperature": 0.4, "max_tokens": 600, "top_p": 0.9}
+
+        try:
+            async with httpx.AsyncClient(timeout=self.timeout) as client:
+                response = await client.post(f"{self.base_url}/chat/completions", json=payload, headers=headers)
+                response.raise_for_status()
+                data = response.json()
+                return data["choices"][0]["message"]["content"].strip()
+        except httpx.TimeoutException:
+            return "⏳ AI response timed out. Please try again."
+        except httpx.HTTPStatusError as e:
+            logger.error("LLM API error: %s - %s", e.response.status_code, e.response.text)
+            return f"⚠️ AI service error ({e.response.status_code}). Check API key or rate limits."
+        except Exception as e:
+            logger.error("Unexpected LLM error: %s", e)
+            return "⚠️ AI service temporarily unavailable. Please try again later."
+
+class RAGService:
+    def __init__(self):
+        self.llm = LLMClient(settings.LLM_PROVIDER, settings.LLM_API_KEY, settings.LLM_BASE_URL, settings.LLM_MODEL)
+        self.conversations: Dict[str, List[Dict[str, str]]] = {}
+        self.max_memory_turns = 6
+        self.system_prompt = """You are ScanLeni AI, an intelligent product analysis assistant.
+Users scan labels via camera OCR, which often produces fragmented, uppercase, or misspelled text (e.g., "cofn" = corn flour, "SWEETCORN", "yummy").
+Your job:
+1. Interpret OCR output intelligently. Correct obvious typos/fragments silently.
+2. Guess the product type (snack, skincare, supplement, household, etc.) based on ingredients.
+3. Analyze safety, allergens, and health impact concisely.
+4. If text is unclear, explain what it likely means and give practical advice. Only ask for clarification if absolutely necessary.
+5. Keep responses conversational, structured, and actionable. Avoid robotic disclaimers like "I couldn't identify...".
+6. Never give medical diagnoses. Suggest consulting professionals for severe allergies/conditions.
+Format naturally: Product Guess → Ingredient Breakdown → Safety Note → Quick Tip."""
+
+    async def chat(self, req: ChatRequest) -> ChatResponse:
+        conv_id = req.conversation_id or str(uuid.uuid4())
+        if conv_id not in self.conversations:
+            self.conversations[conv_id] = []
+
+        context_results = vector_store.search(req.message, top_k=settings.VECTOR_TOP_K)
+        context_texts = [text for text, _, _ in context_results]
+        context_str = "\n".join(context_texts) if context_texts else "No specific safety data retrieved."
+
+        profile_ctx = ""
+        if req.user_profile:
+            parts = []
+            if req.user_profile.conditions: parts.append(f"Conditions: {', '.join(req.user_profile.conditions)}")
+            if req.user_profile.allergies: parts.append(f"Allergies: {', '.join(req.user_profile.allergies)}")
+            if req.user_profile.dietary: parts.append(f"Dietary: {', '.join(req.user_profile.dietary)}")
+            if req.user_profile.skin_type: parts.append(f"Skin Type: {req.user_profile.skin_type}")
+            profile_ctx = " | ".join(parts) if parts else ""
+
+        # Clean OCR context before injecting
+        raw_ctx = req.context_product or ""
+        cleaned_ctx = raw_ctx.replace("Scanned ingredients: ", "").strip()
+        product_section = f"Scanned OCR Output: {cleaned_ctx}" if cleaned_ctx else ""
+        
+        system_context = "\n".join(filter(None, [f"Retrieved Safety Knowledge:\n{context_str}", product_section, f"User Profile: {profile_ctx}"]))
+
+        messages = [
+            {"role": "system", "content": self.system_prompt},
+            {"role": "system", "content": system_context},
+            *self.conversations[conv_id][-self.max_memory_turns:],
+            {"role": "user", "content": req.message}
+        ]
+
+        reply = await self.llm.generate(messages)
+        self.conversations[conv_id].append({"role": "user", "content": req.message})
+        self.conversations[conv_id].append({"role": "assistant", "content": reply})
+        if len(self.conversations[conv_id]) > self.max_memory_turns * 2:
+            self.conversations[conv_id] = self.conversations[conv_id][-self.max_memory_turns * 2:]
+
+        return ChatResponse(
+            conversation_id=conv_id,
+            reply=reply,
+            sources=context_texts,
+            confidence=0.85 if context_texts else 0.60
+        )
+
+rag_service = RAGService()

backend/app/services/recommendation_service.py

@@ -0,0 +1,10 @@
+from app.models.schemas import RiskAnalysis, Recommendation
+
+def find_alternatives(risk: RiskAnalysis, category: str = "general") -> list[Recommendation]:
+    if risk.risk_level == "SAFE":
+        return []
+    return [
+        Recommendation(product_name="PureGlow Serum", reason="Fragrance-free, paraben-free, niacinamide-rich.", match_score=0.92, category="skincare"),
+        Recommendation(product_name="CleanBite Snacks", reason="No HFCS, whole grain, low sodium.", match_score=0.88, category="food"),
+        Recommendation(product_name="EcoHome Cleaner", reason="Plant-based, no phthalates, biodegradable.", match_score=0.85, category="household")
+    ]

backend/app/services/vector_store.py

@@ -0,0 +1,63 @@
+import faiss
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from typing import List, Tuple
+from app.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+class VectorStore:
+    def __init__(self):
+        self.embedder = SentenceTransformer(settings.EMBEDDING_MODEL)
+        self.index = None
+        self.documents = []
+        self.metadata = []
+        self._load_default_kb()
+
+    def _load_default_kb(self):
+        kb_data = [
+            {"text": "sweetcorn, corn, maize: whole grain, generally safe, high in fiber. May cause bloating in sensitive individuals.", "category": "food", "risk": "low"},
+            {"text": "cofn, corn flour, maize flour: refined corn starch, safe, commonly used as thickener. Low nutritional value.", "category": "food", "risk": "low"},
+            {"text": "sugar, sucrose, cane sugar: high glycemic index, linked to metabolic issues, dental decay. Limit intake.", "category": "sweetener", "risk": "moderate"},
+            {"text": "high fructose corn syrup, hfcs: ultra-processed sweetener, strongly linked to insulin resistance and fatty liver.", "category": "sweetener", "risk": "high"},
+            {"text": "parabens, methylparaben, propylparaben: preservatives, potential endocrine disruptors, avoid in pregnancy/skincare.", "category": "preservative", "risk": "high"},
+            {"text": "sodium lauryl sulfate, sls, sodium laureth sulfate, sles: harsh surfactants, strip skin barrier, cause irritation.", "category": "surfactant", "risk": "moderate"},
+            {"text": "fragrance, parfum, aroma: umbrella term for hidden chemicals, common allergen, avoid for sensitive skin/asthma.", "category": "fragrance", "risk": "moderate"},
+            {"text": "retinol, retinyl palmitate, vitamin a: anti-aging active, increases sun sensitivity, strictly avoid during pregnancy.", "category": "active", "risk": "moderate"},
+            {"text": "niacinamide, vitamin b3: barrier repair, anti-inflammatory, safe for acne, rosacea, and pregnancy.", "category": "active", "risk": "low"},
+            {"text": "titanium dioxide, zinc oxide: mineral UV filters, non-nano forms are safe, reef-friendly, low irritation.", "category": "uv_filter", "risk": "low"},
+            {"text": "phenoxyethanol: preservative, safe under 1%, can cause contact dermatitis in high concentrations.", "category": "preservative", "risk": "low"},
+            {"text": "mineral oil, paraffinum liquidum: occlusive, non-comedogenic but traps debris, avoid for acne-prone skin.", "category": "emollient", "risk": "moderate"},
+            {"text": "alcohol denat, sd alcohol: drying solvent, disrupts skin barrier, causes redness, avoid in leave-on skincare.", "category": "solvent", "risk": "moderate"},
+            {"text": "red 40, yellow 5, artificial colors: synthetic dyes, linked to hyperactivity in children, potential allergens.", "category": "additive", "risk": "high"},
+            {"text": "sodium benzoate, potassium sorbate: common preservatives, safe alone but can form benzene with vitamin C in acidic drinks.", "category": "preservative", "risk": "moderate"},
+            {"text": "msg, monosodium glutamate: flavor enhancer, safe for most, may trigger headaches/flushing in sensitive users.", "category": "additive", "risk": "low"},
+            {"text": "xanthan gum, guar gum: natural thickeners, fermented, generally safe, may cause mild digestive upset.", "category": "thickener", "risk": "low"},
+            {"text": "citric acid, ascorbic acid: natural preservatives, pH adjusters, safe, antioxidant properties.", "category": "active", "risk": "low"}
+        ]
+        self.documents = [item["text"] for item in kb_data]
+        self.metadata = kb_data
+        if self.documents:
+            embeddings = self.embedder.encode(self.documents, convert_to_numpy=True)
+            dim = embeddings.shape[1]
+            self.index = faiss.IndexFlatL2(dim)
+            self.index.add(embeddings)
+            logger.info("Vector store initialized with %d documents", len(self.documents))
+
+    def search(self, query: str, top_k: int = 4) -> List[Tuple[str, float, dict]]:
+        if not self.index or len(self.documents) == 0:
+            return []
+        try:
+            q_emb = self.embedder.encode([query], convert_to_numpy=True)
+            D, I = self.index.search(q_emb, top_k)
+            results = []
+            for idx, dist in zip(I[0], D[0]):
+                if idx < len(self.documents):
+                    results.append((self.documents[idx], float(dist), self.metadata[idx]))
+            return results
+        except Exception as e:
+            logger.error("Vector search failed: %s", e)
+            return []
+
+vector_store = VectorStore()

backend/app/utils/preprocessor.py

@@ -0,0 +1,21 @@
+import cv2
+import numpy as np
+from PIL import Image
+import io
+
+def preprocess_image(image_bytes: bytes, max_dim: int = 1500) -> Image.Image:
+    np_img = np.frombuffer(image_bytes, np.uint8)
+    img = cv2.imdecode(np_img, cv2.IMREAD_COLOR)
+    h, w = img.shape[:2]
+    if max(h, w) > max_dim:
+        scale = max_dim / max(h, w)
+        img = cv2.resize(img, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_AREA)
+    img = cv2.fastNlMeansDenoisingColored(img, None, 10, 10, 7, 21)
+    lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB)
+    l, a, b = cv2.split(lab)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    l = clahe.apply(l)
+    img = cv2.merge((l, a, b))
+    img = cv2.cvtColor(img, cv2.COLOR_LAB2BGR)
+    _, encoded = cv2.imencode('.jpg', img)
+    return Image.open(io.BytesIO(encoded.tobytes())).convert("RGB")

backend/backend/.dockerignore

@@ -0,0 +1,10 @@
+.venv
+__pycache__
+*.pyc
+.git
+.github
+.env
+.env.local
+tests/
+*.md
+docker-compose.yml

backend/data/ingredient_graph.json

@@ -0,0 +1,174 @@
+{
+  "nodes": {
+    "parabens": {
+      "category": "preservative",
+      "risk": "high",
+      "effects": [
+        "endocrine_disruption",
+        "skin_irritation"
+      ]
+    },
+    "endocrine_disruption": {},
+    "skin_irritation": {},
+    "retinol": {
+      "category": "active",
+      "risk": "moderate",
+      "effects": [
+        "photosensitivity",
+        "anti_aging"
+      ]
+    },
+    "photosensitivity": {},
+    "anti_aging": {},
+    "fragrance": {
+      "category": "additive",
+      "risk": "moderate",
+      "effects": [
+        "allergen",
+        "respiratory_irritation"
+      ]
+    },
+    "allergen": {},
+    "respiratory_irritation": {},
+    "niacinamide": {
+      "category": "active",
+      "risk": "low",
+      "effects": [
+        "barrier_repair",
+        "anti_inflammatory"
+      ]
+    },
+    "barrier_repair": {},
+    "anti_inflammatory": {},
+    "sodium_lauryl_sulfate": {
+      "category": "surfactant",
+      "risk": "moderate",
+      "effects": [
+        "barrier_stripping",
+        "acne_trigger"
+      ]
+    },
+    "barrier_stripping": {},
+    "acne_trigger": {},
+    "alcohol_denat": {
+      "category": "solvent",
+      "risk": "moderate",
+      "effects": [
+        "drying",
+        "barrier_disruption"
+      ]
+    },
+    "drying": {},
+    "barrier_disruption": {},
+    "mineral_oil": {
+      "category": "emollient",
+      "risk": "moderate",
+      "effects": [
+        "comedogenic",
+        "occlusive"
+      ]
+    },
+    "comedogenic": {},
+    "occlusive": {}
+  },
+  "edges": [
+    [
+      "parabens",
+      "endocrine_disruption",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "parabens",
+      "skin_irritation",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "retinol",
+      "photosensitivity",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "retinol",
+      "anti_aging",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "fragrance",
+      "allergen",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "fragrance",
+      "respiratory_irritation",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "niacinamide",
+      "barrier_repair",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "niacinamide",
+      "anti_inflammatory",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "sodium_lauryl_sulfate",
+      "barrier_stripping",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "sodium_lauryl_sulfate",
+      "acne_trigger",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "alcohol_denat",
+      "drying",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "alcohol_denat",
+      "barrier_disruption",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "mineral_oil",
+      "comedogenic",
+      {
+        "relation": "causes"
+      }
+    ],
+    [
+      "mineral_oil",
+      "occlusive",
+      {
+        "relation": "causes"
+      }
+    ]
+  ]
+}

backend/docker-compose.yml

@@ -0,0 +1,58 @@
+version: '3.8'
+
+services:
+  backend:
+    build: 
+      context: ./backend
+      dockerfile: Dockerfile
+    ports:
+      - "8000:8000"
+    environment:
+      - LLM_API_KEY=${LLM_API_KEY}
+      - LLM_BASE_URL=${LLM_BASE_URL:-https://api.groq.com/openai/v1}
+      - LLM_MODEL=${LLM_MODEL:-llama-3.1-8b-instant}
+      - REDIS_URL=redis://redis:6379/0
+      - DATABASE_URL=postgresql://postgres:postgres@db:5432/scanleni
+    depends_on:
+      - redis
+      - db
+    volumes:
+      - ./backend/app:/app/app:ro
+    restart: unless-stopped
+
+  frontend:
+    image: node:20-alpine
+    working_dir: /app
+    volumes:
+      - ./frontend:/app
+    ports:
+      - "3000:3000"
+    command: sh -c "npm install && npm run dev -- --host"
+    depends_on:
+      - backend
+    restart: unless-stopped
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    command: redis-server --appendonly yes
+    restart: unless-stopped
+
+  db:
+    image: pgvector/pgvector:pg16
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+      POSTGRES_DB: scanleni
+    ports:
+      - "5432:5432"
+    volumes:
+      - pg_data:/var/lib/postgresql/data
+    restart: unless-stopped
+
+volumes:
+  redis_data:
+  pg_data:

backend/requirements.txt

@@ -0,0 +1,19 @@
+fastapi==0.109.0
+uvicorn[standard]==0.27.0
+pydantic==2.5.3
+pydantic-settings==2.1.0
+python-multipart==0.0.6
+python-dotenv==1.0.0
+httpx==0.26.0
+redis==5.0.1
+sqlalchemy==2.0.25
+psycopg2-binary==2.9.9
+faiss-cpu==1.7.4
+sentence-transformers==2.2.2
+numpy==1.26.4
+pillow>=10.0.0
+rapidocr_onnxruntime==1.4.4
+onnxruntime==1.19.2
+opencv-python-headless==4.9.0.80
+prometheus-client==0.19.0
+pytest>=7.4.0