Add application file

api.py

@@ -0,0 +1,408 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from pydantic import BaseModel
+from openai import OpenAI
+from datetime import datetime
+from pathlib import Path
+import requests
+import json
+import re
+import os
+
+app = FastAPI(
+    title="Store Product Search API",
+    description=(
+        "Three-step RAG pipeline for natural-language product search:\n"
+        "  1. User message → NVIDIA Llama 3.1 70B (SQL generator)\n"
+        "  2. Generated SQL → PHP DB layer (execution)\n"
+        "  3. Query results + user message → NVIDIA Llama 3.1 70B (natural language reply)"
+    ),
+)
+
+# ── CORS ───────────────────────────────────────────────────────────────────────
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── Configuration ──────────────────────────────────────────────────────────────
+NVIDIA_API_KEY    = os.environ.get("NVIDIA_API_KEY", "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")      # Set as env/secret
+PHP_DB_URL        = os.environ.get("PHP_DB_URL", "http://localhost/api_ct/db_api.php")
+INTERNAL_SECRET   = os.environ.get("INTERNAL_SECRET", "change_this_secret_in_production")
+
+# Output directory for SQL query results
+OUTPUT_DIR = Path("./sql_results")
+OUTPUT_DIR.mkdir(exist_ok=True)
+
+# NVIDIA LLM Configuration (for SQL generation and natural language replies)
+LLM_URL   = "https://integrate.api.nvidia.com/v1"
+LLM_MODEL = "meta/llama-3.1-70b-instruct"
+
+# Validate API key
+if not NVIDIA_API_KEY:
+    raise RuntimeError(
+        "❌ NVIDIA_API_KEY is not set!\n"
+        "Set it with: export NVIDIA_API_KEY='your_actual_key'\n"
+        "Or add to .env: NVIDIA_API_KEY=your_actual_key"
+    )
+
+# Initialize OpenAI client with NVIDIA base URL (OpenAI-compatible API)
+client = OpenAI(
+    base_url=LLM_URL,
+    api_key=NVIDIA_API_KEY
+)
+
+print(f"✓ NVIDIA API configured with model: {LLM_MODEL}")
+
+# Anthropic kept for reference (can be removed if fully migrating to NVIDIA)
+# ANTHROPIC_URL   = "https://api.anthropic.com/v1/messages"
+# ANTHROPIC_MODEL = "claude-sonnet-4-20250514"
+# ANTHROPIC_HEADERS = {...}
+
+PHP_HEADERS = {
+    "Content-Type":    "application/json",
+    "X-Internal-Secret": INTERNAL_SECRET,
+}
+
+# ── Database schema (injected into the SQL-generation prompt) ─────────────────
+DB_SCHEMA = """
+
+Table: item_master  (main product table)
+Columns:
+  id                INT            Primary key, auto-increment
+  item_name         VARCHAR(1000)  Product name (e.g. 'Bag-B27-BLACK', 'LADIES PURSE B-55', 'WS-253 BLACK PU-SLIPPER')
+  category_id       INT            FK — category (see known category IDs below)
+  subcategory_id    INT            FK — subcategory
+  BrandID           INT            FK — brands
+  VendorID          INT            FK — vendor
+  store_id          INT            Always 1 in this dataset
+  mrp               DOUBLE         MRP price in INR (e.g. 496, 410, 599)
+  hsn               VARCHAR(50)    HSN/tax code (e.g. '4202' for bags, '6405' for footwear, '61112000' for kids clothes, '5407' for sarees)
+  size_dimension    VARCHAR(45)    Physical dimensions or clothing size (e.g. 'W-24 X H-17.5 X B-6', '4, 5, 6, 7', '26, 28, 30')
+  weight            DECIMAL(11,2)  Weight in grams
+  color             VARCHAR(45)    Hex color code (e.g. '#000000' for black, '#ff0000' for red, '#1b1b18' for near-black)
+  packingtype       VARCHAR(30)    Packing type: 'PCS', 'Box', 'Other'
+  packingtime       INT            Days to pack
+  tax_p             DOUBLE         Tax percentage (18 for bags/footwear, 5 for clothing)
+  reorder_qty       INT            Reorder quantity threshold
+  Qty               INT            Current stock quantity (filter Qty >= 0 for in-stock)
+  stock_movement    VARCHAR(50)    Always 'FIFO'
+  saleprice         DOUBLE         Actual selling price in INR (usually mrp/2; use this as the display price)
+  dis_p             DOUBLE         Discount percentage (0–100; if > 0 item is on discount)
+  description       TEXT           Product description
+  status            VARCHAR(20)    'Active' or 'Inactive' — always filter WHERE status = 'Active'
+  ongoing_offer     VARCHAR(11)    'yes' or 'no'
+  discount_percentage VARCHAR(11)  Additional discount label
+
+Known category_id values (approximate — use LIKE on item_name for category filtering):
+  1  = Girls' Frocks / Baby Frocks
+  3  = Sarees (chiffon, dola silk)
+  9  = Men's Footwear (slippers)
+  10 = Women's Footwear (sandals, slippers, heels, flip-flops)
+  11 = Kids' Sets / Combo (boy/girl outfit sets, kids' purses)
+  13 = Bags (backpacks, shoulder bags, sling bags, combo bags)
+  19 = Shoulder Bags / Sling Bags (women)
+  20 = Ladies Purses / Clutches / Wallets
+  21 = Mobile Side Bags / Cross Body Bags
+  22 = Sling Bags / Cross Body Bags
+  23 = Handbags / Clutches / Ladies Sling Bags
+
+Color notes: color is stored as hex (#000000 = Black, #ffffff = White).
+  For color search by name, use item_name LIKE '%COLOR%' (e.g. item_name LIKE '%BLACK%').
+
+Table: product_images  (product photos)
+Columns:
+  image_id    INT           Primary key
+  product_id  INT           FK → item_master.id
+  path_url    VARCHAR(100)  Filename (e.g. '83_1769753521_01.avif') — prepend your base image URL
+  default_img VARCHAR(1)    'y' = primary/default image, 'n' = additional image
+  img_seq     INT           Display order (1 = first shown)
+
+To get the images for a product:
+  LEFT JOIN product_images ON item_master.id = product_images.product_id
+
+Table: brands (brand information)
+Columns:
+  BrandID   INT           Primary key
+  Brand VARCHAR(100)  Brand name (e.g. 'Nike', 'Adidas', 'Reebok')
+
+Table: category (product categories)
+Columns:
+  category_id   INT           Primary key
+  category_name VARCHAR(100)  Category name (e.g. 'Men's Footwear', '')
+
+Table: subcategory (product subcategories)
+Columns:
+  subcategoryid   INT           Primary key
+  subcategory VARCHAR(100)  Subcategory name (e.g. 'Slippers', 'Sarees', 'Kids Sets')
+
+Table: vendor (vendor information)
+Columns:
+  ID   INT           Primary key
+  Name VARCHAR(100)  Vendor name (e.g. 'Vendor A', 'Vendor B')
+"""
+
+# ── System prompts ─────────────────────────────────────────────────────────────
+
+SQL_SYSTEM_PROMPT = f"""You are an expert MySQL query generator for an online fashion store.
+
+DATABASE SCHEMA:
+{DB_SCHEMA}
+
+Your task:
+- Analyse the user's natural language product search request.
+- Generate a single valid MySQL SELECT query that retrieves matching products.
+- ALWAYS include these columns: id, name, category, brand, color, size, gender, price, discount_pct, stock, rating, description
+- Apply WHERE filters based on what the user asked (price, color, size, category, gender, etc.)
+- Use LIKE for partial text matches on name, category, brand, color.
+- For price constraints: "within 500", "under 500", "below 500" → price <= 500; "above 500" → price >= 500; "between X and Y" → price BETWEEN X AND Y
+- For size: match exactly. Map "XXL" → size = 'XXL', "extra large" → size = 'XL', etc.
+- For color: use LIKE '%Blue%' (case-insensitive intent).
+- For product image: use LEFT JOIN product_images ON item_master.id = product_images.product_id AND product_images.default_img = 'y' to get the main image URL.
+- Always filter WHERE stock >= 0 (only show in-stock items).
+- Add ORDER BY rating DESC, price ASC to surface best value first.
+- LIMIT results to 10 rows maximum.
+- Return ONLY the raw SQL query — no markdown fences, no explanation, no preamble. Just the SQL.
+
+Rules:
+- Never use DROP, DELETE, INSERT, UPDATE, ALTER, TRUNCATE, or any DML/DDL.
+- Only SELECT from the item_master table and joined tables.
+- If the user's request is vague (e.g. "I want a nice dress"), generate a broad query that returns popular/relevant items (e.g. SELECT ... WHERE category LIKE '%dress%' OR name LIKE '%dress%' ORDER BY rating DESC LIMIT 10).
+- Don't include Qty column of item_master in WHERE clause.
+- If the request is ambiguous, generate a broad but relevant query.
+"""
+
+RESPONSE_SYSTEM_PROMPT = """You are a helpful, friendly online fashion store assistant named "ShopBot".
+
+Your task:
+- You receive the user's original search query and a JSON array of matching products from the database.
+- Respond in a warm, conversational tone — like a knowledgeable sales assistant.
+- Summarize what was found, highlight 2–3 standout products with specific details (name, price, color, size, rating).
+- If no products are found, suggest alternatives or ask clarifying questions.
+- Keep responses concise (3–5 sentences max unless listing products).
+- Format product listings clearly: use "→" bullet style.
+- Always mention price in ₹ (Indian Rupees).
+- Do NOT mention SQL, databases, or internal systems to the user.
+- End with a helpful follow-up question or offer (e.g., "Want me to filter by a specific color?").
+"""
+
+
+# ── Request / Response models ──────────────────────────────────────────────────
+
+class SearchRequest(BaseModel):
+    message: str
+    conversation_history: list = []   # list of {"role": "user"|"assistant", "content": "..."}
+
+
+class SearchResponse(BaseModel):
+    reply: str
+    products: list
+    generated_sql: str
+    row_count: int
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def generate_sql(user_message: str) -> str:
+    """Step 1: Ask NVIDIA Llama to generate SQL from the user's natural language query."""
+    try:
+        response = client.chat.completions.create(
+            model=LLM_MODEL,
+            messages=[
+                {"role": "system", "content": SQL_SYSTEM_PROMPT},
+                {"role": "user", "content": f"User search query: {user_message}\n\nGenerate the SQL SELECT query."},
+            ],
+            temperature=0.2,
+            top_p=0.7,
+            max_tokens=512,
+        )
+        raw = response.choices[0].message.content.strip()
+    except Exception as e:
+        raise HTTPException(status_code=502, detail=f"NVIDIA SQL-gen error: {str(e)}")
+
+    print("SQL-gen response:", raw)
+
+    # Strip any accidental markdown fences
+    raw = re.sub(r"```sql\s*", "", raw, flags=re.IGNORECASE)
+    raw = re.sub(r"```\s*", "", raw).strip()
+
+    if not raw.upper().startswith("SELECT"):
+        raise HTTPException(
+            status_code=502,
+            detail=f"SQL generator did not return a SELECT statement. Got: {raw[:200]}",
+        )
+
+    print("Generated SQL:", raw)
+    return raw
+
+
+def execute_sql(sql: str) -> dict:
+    """Step 2: Send SQL to the PHP DB layer and get results."""
+    try:
+        resp = requests.post(
+            PHP_DB_URL,
+            headers=PHP_HEADERS,
+            json={"sql": sql},
+            timeout=15,
+        )
+        resp.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        raise HTTPException(status_code=502, detail=f"PHP DB layer error: {str(e)}")
+
+    result = resp.json()
+    print("DB result:", result)
+
+    if not result.get("success", False):
+        raise HTTPException(
+            status_code=422,
+            detail=f"Query failed: {result.get('error', 'Unknown DB error')}",
+        )
+
+    # Save results to file with timestamp
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = OUTPUT_DIR / f"sql_result_{timestamp}.json"
+    
+    output_data = {
+        "timestamp": datetime.now().isoformat(),
+        "sql_query": sql,
+        "results": result.get("results", []),
+        "row_count": result.get("row_count", 0),
+        "execution_status": "success" if result.get("success") else "failed"
+    }
+    
+    try:
+        with open(filename, "w", encoding="utf-8") as f:
+            json.dump(output_data, f, ensure_ascii=False, indent=2)
+        print(f"✓ Results saved to: {filename}")
+    except Exception as e:
+        print(f"⚠️  Failed to save results to file: {str(e)}")
+    
+    return result
+
+
+def generate_reply(user_message: str, products: list, conversation_history: list) -> str:
+    """Step 3: Ask NVIDIA Llama to turn the query results into a friendly response."""
+
+    products_json = json.dumps(products, ensure_ascii=False, indent=2)
+
+    # Build messages: system + history + current turn
+    messages = [{"role": "system", "content": RESPONSE_SYSTEM_PROMPT}]
+    
+    # Add conversation history
+    messages.extend(conversation_history)
+    
+    # Add current user query
+    messages.append({
+        "role": "user",
+        "content": (
+            f"User query: {user_message}\n\n"
+            f"Product search results ({len(products)} items found):\n{products_json}\n\n"
+            f"Please give a helpful, friendly response to the user."
+        ),
+    })
+
+    try:
+        response = client.chat.completions.create(
+            model=LLM_MODEL,
+            messages=messages,
+            temperature=0.2,
+            top_p=0.7,
+            max_tokens=1024,
+        )
+        reply = response.choices[0].message.content.strip()
+    except Exception as e:
+        raise HTTPException(status_code=502, detail=f"NVIDIA reply-gen error: {str(e)}")
+
+    print("Reply response:", reply)
+
+    if not reply:
+        raise HTTPException(status_code=502, detail="LLM returned an empty reply")
+
+    return reply
+
+
+# ── Endpoint ───────────────────────────────────────────────────────────────────
+
+@app.post("/search", response_model=SearchResponse)
+async def product_search(req: SearchRequest):
+    """
+    Natural-language product search endpoint.
+
+    Pipeline:
+      1. user message → Claude (SQL generator) → SQL SELECT statement
+      2. SQL → PHP DB layer → JSON product rows
+      3. products JSON + user message → Claude (ShopBot) → friendly reply
+
+    Body:
+      - message: the user's search text (e.g. "I need a blue XXL shirt under 500")
+      - conversation_history: optional list of prior turns for context
+    """
+    if not req.message.strip():
+        raise HTTPException(status_code=400, detail="Message cannot be empty")
+
+    # Step 1: Generate SQL
+    sql = generate_sql(req.message)
+
+    # Step 2: Execute against DB
+    db_result = execute_sql(sql)
+    products   = db_result.get("results", [])
+    row_count  = db_result.get("row_count", 0)
+
+    # Step 3: Generate friendly response
+    reply = generate_reply(req.message, products, req.conversation_history)
+
+    return SearchResponse(
+        reply=reply,
+        products=products,
+        generated_sql=sql,
+        row_count=row_count,
+    )
+
+
+@app.get("/health")
+async def health():
+    return {"status": "healthy", "model": LLM_MODEL, "provider": "NVIDIA"}
+
+
+@app.get("/results")
+async def list_results():
+    """List all saved SQL query results."""
+    try:
+        files = sorted(OUTPUT_DIR.glob("sql_result_*.json"), reverse=True)
+        results_info = []
+        for f in files[:20]:  # Last 20 results
+            results_info.append({
+                "filename": f.name,
+                "path": str(f),
+                "created": f.stat().st_mtime
+            })
+        return {"status": "success", "results": results_info, "total": len(results_info)}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to list results: {str(e)}")
+
+
+@app.get("/results/{filename}")
+async def get_result(filename: str):
+    """Retrieve a specific saved SQL query result."""
+    filepath = OUTPUT_DIR / filename
+    if not filepath.exists() or not filepath.suffix == ".json":
+        raise HTTPException(status_code=404, detail="Result file not found")
+    
+    try:
+        return FileResponse(filepath, media_type="application/json", filename=filename)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Failed to retrieve result: {str(e)}")
+
+
+@app.get("/")
+async def root():
+    return FileResponse("index.html")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("api:app", host="0.0.0.0", port=8000, reload=True)

index.html

@@ -0,0 +1,554 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1.0" />
+<title>ShopBot — Product Search</title>
+<link rel="preconnect" href="https://fonts.googleapis.com" />
+<link href="https://fonts.googleapis.com/css2?family=DM+Serif+Display:ital@0;1&family=DM+Sans:ital,opsz,wght@0,9..40,300;0,9..40,400;0,9..40,500;1,9..40,300&display=swap" rel="stylesheet" />
+<style>
+  *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }
+
+  :root {
+    --sage:      #3d6b4f;
+    --sage-light:#e8f0eb;
+    --sage-mid:  #a8c4b0;
+    --cream:     #faf8f4;
+    --ink:       #1a1a18;
+    --ink-muted: #6b6b66;
+    --ink-faint: #a8a8a4;
+    --surface:   #ffffff;
+    --border:    rgba(0,0,0,0.08);
+    --accent:    #c17d3c;
+    --accent-bg: #fdf3e7;
+    --radius-sm: 8px;
+    --radius-md: 14px;
+    --radius-lg: 22px;
+  }
+
+  body {
+    font-family: 'DM Sans', sans-serif;
+    background: var(--cream);
+    color: var(--ink);
+    min-height: 100vh;
+    display: flex;
+    flex-direction: column;
+  }
+
+  /* ── HEADER ── */
+  header {
+    padding: 1.25rem 2rem;
+    background: var(--surface);
+    border-bottom: 1px solid var(--border);
+    display: flex;
+    align-items: center;
+    gap: 14px;
+    position: sticky;
+    top: 0;
+    z-index: 100;
+  }
+  .logo-mark {
+    width: 38px; height: 38px;
+    background: var(--sage);
+    border-radius: 10px;
+    display: flex; align-items: center; justify-content: center;
+    flex-shrink: 0;
+  }
+  .logo-mark svg { width: 20px; height: 20px; fill: none; stroke: #fff; stroke-width: 2; stroke-linecap: round; }
+  .header-text h1 { font-family: 'DM Serif Display', serif; font-size: 1.15rem; font-weight: 400; color: var(--ink); letter-spacing: -0.01em; }
+  .header-text p  { font-size: 0.75rem; color: var(--ink-muted); margin-top: 1px; }
+  .status-dot { margin-left: auto; display: flex; align-items: center; gap: 6px; font-size: 0.72rem; color: var(--ink-muted); }
+  .dot { width: 7px; height: 7px; border-radius: 50%; background: #4caf7d; animation: pulse 2s infinite; }
+  @keyframes pulse { 0%,100%{opacity:1} 50%{opacity:.4} }
+
+  /* ── MAIN LAYOUT ── */
+  main {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    max-width: 860px;
+    width: 100%;
+    margin: 0 auto;
+    padding: 0 1rem;
+  }
+
+  /* ── CHAT AREA ── */
+  #chat {
+    flex: 1;
+    overflow-y: auto;
+    padding: 2rem 0 1rem;
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+    min-height: 0;
+  }
+
+  /* ── WELCOME ── */
+  .welcome {
+    text-align: center;
+    padding: 3rem 1rem 2rem;
+  }
+  .welcome-icon {
+    width: 64px; height: 64px;
+    background: var(--sage-light);
+    border-radius: 18px;
+    display: flex; align-items: center; justify-content: center;
+    margin: 0 auto 1.25rem;
+  }
+  .welcome-icon svg { width: 32px; height: 32px; stroke: var(--sage); fill: none; stroke-width: 1.8; stroke-linecap: round; }
+  .welcome h2 { font-family: 'DM Serif Display', serif; font-size: 1.7rem; font-weight: 400; color: var(--ink); margin-bottom: 0.5rem; }
+  .welcome p  { font-size: 0.88rem; color: var(--ink-muted); max-width: 360px; margin: 0 auto 1.75rem; line-height: 1.6; }
+  .chips { display: flex; flex-wrap: wrap; justify-content: center; gap: 8px; }
+  .chip {
+    padding: 7px 14px;
+    border-radius: 999px;
+    border: 1px solid var(--border);
+    background: var(--surface);
+    font-size: 0.78rem;
+    color: var(--ink-muted);
+    cursor: pointer;
+    transition: all .15s;
+  }
+  .chip:hover { border-color: var(--sage-mid); color: var(--sage); background: var(--sage-light); }
+
+  /* ── MESSAGE BUBBLES ── */
+  .msg { display: flex; gap: 10px; }
+  .msg.user  { flex-direction: row-reverse; }
+  .msg.bot   { flex-direction: row; }
+
+  .avatar {
+    width: 30px; height: 30px; border-radius: 50%;
+    flex-shrink: 0; display: flex; align-items: center; justify-content: center;
+    font-size: 0.7rem; font-weight: 500; margin-top: 2px;
+  }
+  .avatar.bot  { background: var(--sage); color: #fff; }
+  .avatar.user { background: var(--ink); color: #fff; font-size: 0.65rem; }
+
+  .bubble {
+    max-width: 75%;
+    padding: 0.85rem 1.1rem;
+    border-radius: var(--radius-lg);
+    font-size: 0.875rem;
+    line-height: 1.65;
+  }
+  .msg.user .bubble {
+    background: var(--ink);
+    color: #fff;
+    border-bottom-right-radius: var(--radius-sm);
+  }
+  .msg.bot .bubble {
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-bottom-left-radius: var(--radius-sm);
+    color: var(--ink);
+  }
+
+  /* ── PRODUCT GRID ── */
+  .products-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(190px, 1fr));
+    gap: 10px;
+    margin-top: 12px;
+  }
+  .product-card {
+    background: var(--cream);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-md);
+    padding: 12px;
+    cursor: pointer;
+    transition: all .2s;
+    position: relative;
+  }
+  .product-card:hover { border-color: var(--sage-mid); transform: translateY(-1px); }
+  .product-card .badge {
+    position: absolute; top: 10px; right: 10px;
+    background: var(--accent-bg);
+    color: var(--accent);
+    font-size: 0.65rem;
+    font-weight: 500;
+    padding: 2px 7px;
+    border-radius: 999px;
+  }
+  .product-img {
+    width: 100%; height: 100px;
+    background: var(--sage-light);
+    border-radius: var(--radius-sm);
+    display: flex; align-items: center; justify-content: center;
+    margin-bottom: 10px;
+    overflow: hidden;
+  }
+  .product-img svg { width: 36px; height: 36px; stroke: var(--sage); fill: none; stroke-width: 1.4; }
+  .product-img img { width: 100%; height: 100%; object-fit: cover; }
+  .product-name { font-size: 0.8rem; font-weight: 500; color: var(--ink); margin-bottom: 4px; line-height: 1.3; }
+  .product-meta { font-size: 0.7rem; color: var(--ink-muted); display: flex; gap: 6px; flex-wrap: wrap; margin-bottom: 6px; }
+  .product-price { font-size: 0.95rem; font-weight: 500; color: var(--sage); }
+  .product-rating { font-size: 0.7rem; color: var(--accent); }
+
+  /* ── SQL DEBUG ── */
+  .sql-block {
+    margin-top: 10px;
+    background: #f4f4f0;
+    border-radius: var(--radius-sm);
+    padding: 8px 12px;
+    font-family: 'Courier New', monospace;
+    font-size: 0.7rem;
+    color: var(--ink-muted);
+    white-space: pre-wrap;
+    word-break: break-all;
+    border-left: 3px solid var(--sage-mid);
+    cursor: pointer;
+  }
+  .sql-label { font-size: 0.65rem; color: var(--ink-faint); margin-bottom: 4px; text-transform: uppercase; letter-spacing: 0.05em; }
+  .sql-toggle { font-size: 0.72rem; color: var(--ink-muted); cursor: pointer; display: inline-flex; align-items: center; gap: 4px; margin-top: 8px; }
+  .sql-toggle:hover { color: var(--sage); }
+
+  /* ── TYPING INDICATOR ── */
+  .typing { display: flex; gap: 5px; align-items: center; padding: 12px 16px; }
+  .typing span {
+    width: 6px; height: 6px; border-radius: 50%;
+    background: var(--sage-mid); display: inline-block;
+    animation: bounce 1.2s infinite;
+  }
+  .typing span:nth-child(2) { animation-delay: .2s; }
+  .typing span:nth-child(3) { animation-delay: .4s; }
+  @keyframes bounce { 0%,100%{transform:translateY(0)} 50%{transform:translateY(-5px)} }
+
+  /* ── INPUT BAR ── */
+  .input-bar {
+    padding: 1rem 0 1.5rem;
+    position: sticky;
+    bottom: 0;
+    background: linear-gradient(to top, var(--cream) 80%, transparent);
+  }
+  .input-wrap {
+    display: flex;
+    align-items: flex-end;
+    gap: 10px;
+    background: var(--surface);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-lg);
+    padding: 10px 10px 10px 16px;
+    box-shadow: 0 2px 16px rgba(0,0,0,0.06);
+  }
+  #user-input {
+    flex: 1;
+    border: none;
+    outline: none;
+    resize: none;
+    font-family: 'DM Sans', sans-serif;
+    font-size: 0.875rem;
+    color: var(--ink);
+    background: transparent;
+    line-height: 1.5;
+    max-height: 120px;
+    min-height: 22px;
+  }
+  #user-input::placeholder { color: var(--ink-faint); }
+  #send-btn {
+    width: 36px; height: 36px;
+    border-radius: 50%;
+    border: none;
+    background: var(--sage);
+    color: #fff;
+    cursor: pointer;
+    display: flex; align-items: center; justify-content: center;
+    transition: all .15s;
+    flex-shrink: 0;
+  }
+  #send-btn:hover { background: #2e5039; transform: scale(1.05); }
+  #send-btn:disabled { background: var(--ink-faint); cursor: not-allowed; transform: none; }
+  #send-btn svg { width: 16px; height: 16px; stroke: #fff; fill: none; stroke-width: 2.2; stroke-linecap: round; }
+
+  .hint { text-align: center; font-size: 0.68rem; color: var(--ink-faint); margin-top: 8px; }
+
+  /* ── CATEGORY ICONS ── */
+  .cat-icon { width: 36px; height: 36px; stroke: var(--sage); fill: none; stroke-width: 1.4; }
+</style>
+</head>
+<body>
+
+<header>
+  <div class="logo-mark">
+    <svg viewBox="0 0 24 24"><path d="M6 2l.01 6L10 12l-3.99 4.01L6 22h12v-6l-4-4 4-3.99V2H6z"/></svg>
+  </div>
+  <div class="header-text">
+    <h1>ShopBot</h1>
+    <p>AI-powered product search</p>
+  </div>
+  <div class="status-dot"><span class="dot"></span> Live</div>
+</header>
+
+<main>
+  <div id="chat">
+    <div class="welcome" id="welcome">
+      <div class="welcome-icon">
+        <svg viewBox="0 0 24 24"><circle cx="11" cy="11" r="8"/><path d="M21 21l-4.35-4.35"/></svg>
+      </div>
+      <h2>What are you looking for?</h2>
+      <p>Describe what you need in plain language — size, color, price, category — and I'll find it.</p>
+      <div class="chips">
+        <span class="chip" onclick="setInput('Blue dress under ₹500')">Blue dress under ₹500</span>
+        <span class="chip" onclick="setInput('XXL white shirt for men')">XXL white shirt for men</span>
+        <span class="chip" onclick="setInput('Nike running shoes size 9')">Nike shoes size 9</span>
+        <span class="chip" onclick="setInput('Women ethnic wear below 700')">Women ethnic below ₹700</span>
+        <span class="chip" onclick="setInput('Best rated jeans')">Best rated jeans</span>
+      </div>
+    </div>
+  </div>
+
+  <div class="input-bar">
+    <div class="input-wrap">
+      <textarea id="user-input" rows="1" placeholder="Try: 'I need a red XXL shirt within ₹500'…" maxlength="400"></textarea>
+      <button id="send-btn" onclick="sendMessage()" title="Search">
+        <svg viewBox="0 0 24 24"><line x1="22" y1="2" x2="11" y2="13"/><polygon points="22 2 15 22 11 13 2 9 22 2"/></svg>
+      </button>
+    </div>
+    <p class="hint">Press Enter to send · Shift+Enter for new line</p>
+  </div>
+</main>
+
+<script>
+const API_BASE = "";  // same origin; change to "http://localhost:8000" for dev
+let history = [];
+let isLoading = false;
+
+const chatEl   = document.getElementById("chat");
+const inputEl  = document.getElementById("user-input");
+const sendBtn  = document.getElementById("send-btn");
+const welcomeEl= document.getElementById("welcome");
+
+function setInput(text) {
+  inputEl.value = text;
+  inputEl.focus();
+  autoResize();
+}
+
+inputEl.addEventListener("keydown", e => {
+  if (e.key === "Enter" && !e.shiftKey) { e.preventDefault(); sendMessage(); }
+});
+inputEl.addEventListener("input", autoResize);
+function autoResize() {
+  inputEl.style.height = "auto";
+  inputEl.style.height = Math.min(inputEl.scrollHeight, 120) + "px";
+}
+
+function sendMessage() {
+  const text = inputEl.value.trim();
+  if (!text || isLoading) return;
+
+  if (welcomeEl) { welcomeEl.style.display = "none"; }
+
+  appendBubble("user", text);
+  inputEl.value = "";
+  autoResize();
+
+  const typingId = appendTyping();
+  setLoading(true);
+
+  fetch(`${API_BASE}/search`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ message: text, conversation_history: history }),
+  })
+  .then(r => r.json())
+  .then(data => {
+    removeTyping(typingId);
+    setLoading(false);
+
+    if (data.detail) {
+      appendBubble("bot", `⚠️ ${data.detail}`);
+      return;
+    }
+
+    history.push({ role: "user",      content: text });
+    history.push({ role: "assistant", content: data.reply });
+    if (history.length > 20) history = history.slice(-20);
+
+    appendBotResponse(data);
+  })
+  .catch(err => {
+    removeTyping(typingId);
+    setLoading(false);
+    appendBubble("bot", "Connection error. Is the server running? (" + err.message + ")");
+  });
+}
+
+function setLoading(v) {
+  isLoading = v;
+  sendBtn.disabled = v;
+}
+
+function appendBubble(role, text) {
+  const wrap = document.createElement("div");
+  wrap.className = "msg " + role;
+
+  const av = document.createElement("div");
+  av.className = "avatar " + role;
+  av.textContent = role === "bot" ? "S" : "You";
+
+  const bub = document.createElement("div");
+  bub.className = "bubble";
+  bub.textContent = text;
+
+  wrap.appendChild(av);
+  wrap.appendChild(bub);
+  chatEl.appendChild(wrap);
+  scrollToBottom();
+  return wrap;
+}
+
+function appendBotResponse(data) {
+  const wrap = document.createElement("div");
+  wrap.className = "msg bot";
+
+  const av = document.createElement("div");
+  av.className = "avatar bot";
+  av.textContent = "S";
+
+  const bub = document.createElement("div");
+  bub.className = "bubble";
+
+  const replyText = document.createElement("div");
+  replyText.style.marginBottom = data.products && data.products.length ? "12px" : "0";
+  replyText.textContent = data.reply;
+  bub.appendChild(replyText);
+
+  // Product grid
+  if (data.products && data.products.length > 0) {
+    const grid = document.createElement("div");
+    grid.className = "products-grid";
+    data.products.forEach(p => grid.appendChild(makeCard(p)));
+    bub.appendChild(grid);
+  }
+
+  // SQL debug toggle
+  if (data.generated_sql) {
+    const toggle = document.createElement("span");
+    toggle.className = "sql-toggle";
+    toggle.innerHTML = `<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></svg> View generated SQL`;
+    const sqlBlock = document.createElement("div");
+    sqlBlock.className = "sql-block";
+    sqlBlock.style.display = "none";
+    const label = document.createElement("div");
+    label.className = "sql-label";
+    label.textContent = "Generated SQL · " + (data.row_count || 0) + " results";
+    const code = document.createElement("code");
+    code.textContent = data.generated_sql;
+    sqlBlock.appendChild(label);
+    sqlBlock.appendChild(code);
+
+    let open = false;
+    toggle.onclick = () => {
+      open = !open;
+      sqlBlock.style.display = open ? "block" : "none";
+      toggle.innerHTML = (open
+        ? `<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="18 15 12 9 6 15"/></svg> Hide SQL`
+        : `<svg width="12" height="12" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="16 18 22 12 16 6"/><polyline points="8 6 2 12 8 18"/></svg> View generated SQL`);
+    };
+    bub.appendChild(toggle);
+    bub.appendChild(sqlBlock);
+  }
+
+  wrap.appendChild(av);
+  wrap.appendChild(bub);
+  chatEl.appendChild(wrap);
+  scrollToBottom();
+}
+
+function makeCard(p) {
+  const card = document.createElement("div");
+  card.className = "product-card";
+  card.title = p.description || p.name;
+
+  const discountPct = parseInt(p.discount_pct) || 0;
+  if (discountPct > 0) {
+    const badge = document.createElement("div");
+    badge.className = "badge";
+    badge.textContent = `-${discountPct}%`;
+    card.appendChild(badge);
+  }
+
+  const img = document.createElement("div");
+  img.className = "product-img";
+  if (p.image_url) {
+    const i = document.createElement("img");
+    i.src = 'http://localhost/api_ct/productimage/'+p.image_url;
+    i.alt = p.name;
+    i.onerror = () => { img.innerHTML = categoryIcon(p.category); };
+    img.appendChild(i);
+  } else {
+    img.innerHTML = categoryIcon(p.category);
+  }
+  card.appendChild(img);
+
+  const name = document.createElement("div");
+  name.className = "product-name";
+  name.textContent = p.name;
+  card.appendChild(name);
+
+  const meta = document.createElement("div");
+  meta.className = "product-meta";
+  if (p.color) meta.innerHTML += `<span>${p.color}</span>`;
+  if (p.size)  meta.innerHTML += `<span>· ${p.size}</span>`;
+  if (p.brand) meta.innerHTML += `<span>· ${p.brand}</span>`;
+  card.appendChild(meta);
+
+  const bottom = document.createElement("div");
+  bottom.style.display = "flex"; bottom.style.justifyContent = "space-between"; bottom.style.alignItems = "center";
+  const price = document.createElement("div");
+  price.className = "product-price";
+  const finalPrice = discountPct > 0 ? (parseFloat(p.price) * (1 - discountPct/100)).toFixed(0) : parseFloat(p.price).toFixed(0);
+  price.textContent = `₹${finalPrice}`;
+  if (discountPct > 0) {
+    const original = document.createElement("span");
+    original.style.cssText = "font-size:0.65rem;color:#a8a8a4;text-decoration:line-through;margin-left:4px;";
+    original.textContent = `₹${parseFloat(p.price).toFixed(0)}`;
+    price.appendChild(original);
+  }
+  const rating = document.createElement("div");
+  rating.className = "product-rating";
+  if (p.rating) rating.textContent = `★ ${parseFloat(p.rating).toFixed(1)}`;
+  bottom.appendChild(price);
+  bottom.appendChild(rating);
+  card.appendChild(bottom);
+
+  return card;
+}
+
+function categoryIcon(cat) {
+  const c = (cat || "").toLowerCase();
+  if (c.includes("dress") || c.includes("kurti"))
+    return `<svg class="cat-icon" viewBox="0 0 24 24"><path d="M12 2l-4 4H5l2 4v12h10V10l2-4h-3L12 2z"/></svg>`;
+  if (c.includes("shirt") || c.includes("t-shirt") || c.includes("tee"))
+    return `<svg class="cat-icon" viewBox="0 0 24 24"><path d="M2 7l4-4 4 4v13H2V7zm20 0l-4-4-4 4v13h8V7z"/><line x1="6" y1="7" x2="18" y2="7"/></svg>`;
+  if (c.includes("jean") || c.includes("pant"))
+    return `<svg class="cat-icon" viewBox="0 0 24 24"><path d="M4 2h16v4l-2 16h-4l-2-8-2 8H6L4 6V2z"/></svg>`;
+  if (c.includes("shoe") || c.includes("sandal") || c.includes("sneaker"))
+    return `<svg class="cat-icon" viewBox="0 0 24 24"><path d="M3 16l2-8h6l2 4h7a1 1 0 010 2l-1 2H3z"/><line x1="7" y1="8" x2="7" y2="16"/></svg>`;
+  return `<svg class="cat-icon" viewBox="0 0 24 24"><rect x="3" y="3" width="18" height="18" rx="2"/><path d="M9 3v18M15 3v18"/></svg>`;
+}
+
+function appendTyping() {
+  const id = "typing-" + Date.now();
+  const wrap = document.createElement("div");
+  wrap.className = "msg bot"; wrap.id = id;
+  const av = document.createElement("div");
+  av.className = "avatar bot"; av.textContent = "S";
+  const bub = document.createElement("div");
+  bub.className = "bubble";
+  bub.innerHTML = `<div class="typing"><span></span><span></span><span></span></div>`;
+  wrap.appendChild(av); wrap.appendChild(bub);
+  chatEl.appendChild(wrap);
+  scrollToBottom();
+  return id;
+}
+function removeTyping(id) {
+  const el = document.getElementById(id);
+  if (el) el.remove();
+}
+function scrollToBottom() {
+  chatEl.scrollTop = chatEl.scrollHeight;
+}
+</script>
+</body>
+</html>

rag_api.py

@@ -0,0 +1,313 @@
+"""
+Product RAG API - Retrieval-Augmented Generation for E-Commerce Chat
+Helps users discover products through natural language queries
+Uses NVIDIA Mistral models for intelligent recommendations
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+import os
+from dotenv import load_dotenv
+import numpy as np
+from sentence_transformers import SentenceTransformer
+import faiss
+import json
+import requests
+
+# Load environment variables
+load_dotenv()
+
+# ── Configuration ─────────────────────────────────────────────────────────────
+NVIDIA_API_KEY = os.getenv("NVIDIA_API_KEY", "")
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"  # Fast, lightweight model
+NVIDIA_API_URL = "https://integrate.api.nvidia.com/v1/chat/completions"
+NVIDIA_MODEL = os.getenv("NVIDIA_MODEL", "mistralai/mistral-medium-3.5-128b")
+
+app = FastAPI(
+    title="Product RAG API",
+    description="Retrieval-Augmented Generation for e-commerce product search and recommendations",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ── Validate Configuration ────────────────────────────────────────────────────
+if not NVIDIA_API_KEY:
+    print("⚠️  WARNING: NVIDIA_API_KEY not set. Set it in .env file")
+else:
+    print(f"✓ NVIDIA_API_KEY configured (last 8 chars: ...{NVIDIA_API_KEY[-8:]})")
+
+print(f"✓ Using NVIDIA model: {NVIDIA_MODEL}")
+print(f"✓ NVIDIA API endpoint: {NVIDIA_API_URL}")
+
+# ── Initialize Embedding Model ────────────────────────────────────────────────
+try:
+    embedding_model = SentenceTransformer(EMBEDDING_MODEL)
+    print(f"✓ Embedding model loaded: {EMBEDDING_MODEL}")
+except Exception as e:
+    print(f"✗ Failed to load embedding model: {e}")
+    embedding_model = None
+
+# ── System Prompt ─────────────────────────────────────────────────────────────
+RAG_SYSTEM_PROMPT = """You are a helpful e-commerce shopping assistant. 
+Your goal is to help customers find the perfect products based on their needs.
+
+Given the customer's query and a list of relevant products from the catalog, provide:
+1. A friendly, natural response addressing their query
+2. Specific product recommendations with brief explanations why each product fits their needs
+3. Price and key feature information
+4. Alternative suggestions if appropriate
+
+Keep responses concise, helpful, and focused on the products provided.
+Format product recommendations clearly with product names, prices, and key features."""
+
+# ── Pydantic Models ───────────────────────────────────────────────────────────
+
+class Product(BaseModel):
+    id: str | int
+    name: str
+    description: str
+    price: float
+    category: str
+    brand: Optional[str] = None
+    image_path: Optional[str] = None
+    rating: Optional[float] = None
+
+
+class SearchRequest(BaseModel):
+    query: str
+    products: List[Product]
+    top_k: int = 5  # Number of products to retrieve
+
+
+class RecommendedProduct(BaseModel):
+    id: str | int
+    name: str
+    price: float
+    reason: Optional[str] = None
+
+
+class SearchResponse(BaseModel):
+    message: str
+    products: List[RecommendedProduct]
+    timestamp: str
+
+
+# ── RAG Functions ─────────────────────────────────────────────────────────────
+
+def create_embeddings(texts: List[str]) -> np.ndarray:
+    """Create embeddings for a list of texts using sentence-transformers"""
+    if not embedding_model:
+        raise HTTPException(status_code=500, detail="Embedding model not initialized")
+    
+    embeddings = embedding_model.encode(texts, convert_to_numpy=True)
+    return embeddings
+
+
+def search_products(
+    query: str,
+    products: List[Product],
+    top_k: int = 5
+) -> List[Product]:
+    """
+    Search for relevant products using vector similarity
+    Returns top_k most relevant products
+    """
+    if not products:
+        return []
+    
+    if len(products) <= top_k:
+        return products
+    
+    # Create product descriptions for embedding
+    product_texts = [
+        f"{p.name} {p.category} {p.brand or ''} {p.description}".strip()
+        for p in products
+    ]
+    
+    # Encode query and products
+    query_embedding = embedding_model.encode([query], convert_to_numpy=True)[0]
+    product_embeddings = create_embeddings(product_texts)
+    
+    # Use FAISS for efficient similarity search
+    embedding_dim = product_embeddings.shape[1]
+    index = faiss.IndexFlatL2(embedding_dim)
+    index.add(product_embeddings.astype(np.float32))
+    
+    # Search for top_k similar products
+    query_vector = np.array([query_embedding], dtype=np.float32)
+    distances, indices = index.search(query_vector, min(top_k, len(products)))
+    
+    # Return relevant products in order
+    relevant_products = [products[i] for i in indices[0]]
+    return relevant_products
+
+
+def generate_rag_response(
+    query: str,
+    relevant_products: List[Product]
+) -> tuple[str, List[RecommendedProduct]]:
+    """
+    Generate LLM response using RAG with retrieved products via NVIDIA API
+    Returns (message, recommended_products)
+    """
+    if not NVIDIA_API_KEY:
+        raise HTTPException(
+            status_code=500,
+            detail="NVIDIA_API_KEY not configured. Add to .env file"
+        )
+    
+    # Format products for the prompt
+    product_context = "\n".join([
+        f"- {p.name} (ID: {p.id}) - ₹{p.price} - {p.category} - {p.description}"
+        for p in relevant_products
+    ])
+    
+    # Prepare NVIDIA API request
+    headers = {
+        "Authorization": f"Bearer {NVIDIA_API_KEY}",
+        "Accept": "application/json"
+    }
+    
+    payload = {
+        "model": NVIDIA_MODEL,
+        "messages": [
+            {"role": "system", "content": RAG_SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": f"""Customer query: {query}
+
+Available products from our catalog:
+{product_context}
+
+Please provide personalized recommendations based on these products."""
+            }
+        ],
+        "max_tokens": 500,
+        "temperature": 0.7,
+        "top_p": 1.0,
+        "stream": False
+    }
+    
+    try:
+        response = requests.post(NVIDIA_API_URL, headers=headers, json=payload, timeout=30)
+        response.raise_for_status()
+        
+        result = response.json()
+        ai_message = result.get("choices", [{}])[0].get("message", {}).get("content", "")
+        
+        if not ai_message:
+            raise HTTPException(
+                status_code=502,
+                detail="NVIDIA API returned empty response"
+            )
+        
+        # Format recommended products
+        recommended = [
+            RecommendedProduct(
+                id=p.id,
+                name=p.name,
+                price=p.price,
+                reason=f"{p.category} - {p.description[:100]}"
+            )
+            for p in relevant_products
+        ]
+        
+        return ai_message, recommended
+        
+    except requests.exceptions.RequestException as e:
+        error_msg = str(e)
+        if hasattr(e.response, 'text'):
+            error_msg = f"{error_msg}: {e.response.text}"
+        print(f"NVIDIA API error: {error_msg}")
+        raise HTTPException(status_code=502, detail=f"NVIDIA API error: {error_msg}")
+    except Exception as e:
+        print(f"Unexpected error calling NVIDIA API: {str(e)}")
+        raise HTTPException(status_code=502, detail=f"LLM error: {str(e)}")
+
+
+# ── Endpoints ─────────────────────────────────────────────────────────────────
+
+@app.post("/search-products", response_model=SearchResponse)
+async def search_products_endpoint(request: SearchRequest) -> SearchResponse:
+    """
+    Main RAG endpoint for product search and recommendations
+    
+    1. Retrieves relevant products based on query
+    2. Generates AI response with recommendations
+    3. Returns message + product list
+    """
+    if not request.query.strip():
+        raise HTTPException(status_code=400, detail="Query cannot be empty")
+    
+    if not request.products:
+        raise HTTPException(status_code=400, detail="Products list cannot be empty")
+    
+    # Step 1: Retrieve relevant products
+    relevant_products = search_products(
+        request.query,
+        request.products,
+        request.top_k
+    )
+    
+    # Step 2: Generate LLM response with retrieved products
+    ai_message, recommended_products = generate_rag_response(
+        request.query,
+        relevant_products
+    )
+    
+    # Step 3: Return response
+    from datetime import datetime
+    return SearchResponse(
+        message=ai_message,
+        products=recommended_products,
+        timestamp=datetime.utcnow().isoformat()
+    )
+
+
+@app.get("/health")
+async def health():
+    """Health check endpoint"""
+    return {
+        "status": "healthy",
+        "embedding_model": EMBEDDING_MODEL,
+        "llm": NVIDIA_MODEL,
+        "provider": "NVIDIA",
+        "rag_enabled": embedding_model is not None and bool(NVIDIA_API_KEY)
+    }
+
+
+@app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "name": "Product RAG API",
+        "version": "2.0.0",
+        "description": "Retrieval-Augmented Generation for e-commerce product recommendations",
+        "pipeline": "Sentence-Transformers → FAISS → NVIDIA Mistral",
+        "model": NVIDIA_MODEL,
+        "provider": "NVIDIA",
+        "endpoints": {
+            "POST /search-products": "Search products and get AI recommendations",
+            "GET  /health": "Health check",
+            "GET  /docs": "Swagger UI (API documentation)",
+        },
+        "how_to_use": {
+            "step_1": "Call POST /search-products with customer query and product list",
+            "step_2": "API retrieves relevant products using semantic search",
+            "step_3": "NVIDIA Mistral generates personalized recommendation message",
+            "returns": "AI-generated message + recommended products with prices"
+        }
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("rag_api:app", host="0.0.0.0", port=8004, reload=True)

rag_integration.php

@@ -0,0 +1,223 @@
+<?php
+/**
+ * RAG Integration for Chat - PHP Integration Layer
+ * Connects PHP backend with Python RAG API (powered by NVIDIA Mistral)
+ * 
+ * This file provides functions to:
+ * 1. Fetch products from database
+ * 2. Call the RAG API
+ * 3. Format and return responses to the frontend
+ * 
+ * The RAG API uses:
+ * - Sentence-Transformers for semantic search
+ * - FAISS for vector similarity
+ * - NVIDIA Mistral models for intelligent recommendations
+ */
+
+// Configuration
+define('RAG_API_URL', getenv('RAG_API_URL') ?: 'http://localhost:8004');
+define('RAG_ENDPOINT', '/search-products');
+
+/**
+ * Fetch products from database
+ * Customize this function based on your database schema
+ * 
+ * @param mysqli $conn Database connection
+ * @param string $category Optional category filter
+ * @param int $limit Max products to fetch
+ * @return array Array of product objects
+ */
+function get_products_for_rag($conn, $category = null, $limit = 50) {
+    $query = "SELECT id, name, description, price, category, brand, image_path, rating 
+              FROM products 
+              WHERE status = 'active'";
+    
+    if ($category) {
+        $category = $conn->real_escape_string($category);
+        $query .= " AND category = '$category'";
+    }
+    
+    $query .= " LIMIT $limit";
+    
+    $result = $conn->query($query);
+    
+    if (!$result) {
+        error_log("Database error in get_products_for_rag: " . $conn->error);
+        return [];
+    }
+    
+    $products = [];
+    while ($row = $result->fetch_assoc()) {
+        $products[] = [
+            'id' => (int)$row['id'],
+            'name' => $row['name'],
+            'description' => $row['description'],
+            'price' => (float)$row['price'],
+            'category' => $row['category'],
+            'brand' => $row['brand'] ?? null,
+            'image_path' => $row['image_path'] ?? null,
+            'rating' => $row['rating'] ?? null,
+        ];
+    }
+    
+    return $products;
+}
+
+/**
+ * Call the RAG API for product recommendations
+ * 
+ * @param string $query User's natural language query
+ * @param array $products Array of product objects
+ * @param int $top_k Number of top recommendations to return
+ * @return array|false Response from RAG API or false on error
+ */
+function call_rag_api($query, $products, $top_k = 5) {
+    if (!$query || empty($products)) {
+        error_log("RAG API error: Empty query or products");
+        return false;
+    }
+    
+    // Prepare payload
+    $payload = [
+        'query' => $query,
+        'products' => $products,
+        'top_k' => $top_k
+    ];
+    
+    // Make POST request to RAG API
+    $ch = curl_init();
+    curl_setopt($ch, CURLOPT_URL, RAG_API_URL . RAG_ENDPOINT);
+    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+    curl_setopt($ch, CURLOPT_POST, true);
+    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
+    curl_setopt($ch, CURLOPT_HTTPHEADER, [
+        'Content-Type: application/json',
+        'Accept: application/json'
+    ]);
+    curl_setopt($ch, CURLOPT_TIMEOUT, 30);
+    
+    $response = curl_exec($ch);
+    $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+    $curl_error = curl_error($ch);
+    curl_close($ch);
+    
+    // Handle curl errors
+    if ($curl_error) {
+        error_log("RAG API curl error: $curl_error");
+        return false;
+    }
+    
+    // Handle HTTP errors
+    if ($http_code !== 200) {
+        error_log("RAG API HTTP error: $http_code - $response");
+        return false;
+    }
+    
+    // Parse and return response
+    $data = json_decode($response, true);
+    if (!$data) {
+        error_log("RAG API response parse error: " . json_last_error_msg());
+        return false;
+    }
+    
+    return $data;
+}
+
+/**
+ * Check if RAG API is healthy
+ * 
+ * @return bool True if API is responsive
+ */
+function check_rag_health() {
+    $ch = curl_init();
+    curl_setopt($ch, CURLOPT_URL, RAG_API_URL . '/health');
+    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+    curl_setopt($ch, CURLOPT_TIMEOUT, 5);
+    
+    curl_exec($ch);
+    $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
+    curl_close($ch);
+    
+    return $http_code === 200;
+}
+
+/**
+ * Main function: Get AI recommendations for user query
+ * This is the primary function to call from your chat endpoint
+ * 
+ * @param mysqli $conn Database connection
+ * @param string $user_query User's question/query
+ * @param string $category Optional product category to search in
+ * @return array Response containing message and products
+ */
+function get_rag_recommendations($conn, $user_query, $category = null) {
+    // Check RAG API health
+    if (!check_rag_health()) {
+        error_log("RAG API is not available");
+        return [
+            'success' => false,
+            'message' => 'Recommendation service temporarily unavailable',
+            'products' => []
+        ];
+    }
+    
+    // Fetch products from database
+    $products = get_products_for_rag($conn, $category, 50);
+    
+    if (empty($products)) {
+        return [
+            'success' => false,
+            'message' => 'No products available for recommendation',
+            'products' => []
+        ];
+    }
+    
+    // Call RAG API
+    $rag_response = call_rag_api($user_query, $products, 5);
+    
+    if (!$rag_response) {
+        error_log("Failed to get RAG recommendations");
+        return [
+            'success' => false,
+            'message' => 'Failed to generate recommendations',
+            'products' => []
+        ];
+    }
+    
+    return [
+        'success' => true,
+        'message' => $rag_response['message'] ?? 'No message',
+        'products' => $rag_response['products'] ?? [],
+        'timestamp' => $rag_response['timestamp'] ?? date('c')
+    ];
+}
+
+// ── Example Usage (if this file is called directly) ──────────────────────────
+
+if ($_SERVER['REQUEST_METHOD'] === 'POST' && php_sapi_name() !== 'cli') {
+    header('Content-Type: application/json');
+    
+    $input = json_decode(file_get_contents('php://input'), true);
+    $query = $input['query'] ?? '';
+    
+    if (!$query) {
+        http_response_code(400);
+        echo json_encode(['error' => 'Query is required']);
+        exit;
+    }
+    
+    // Include your database connection
+    // require_once 'db.php';
+    
+    // Uncomment below when integrated with your system:
+    // $result = get_rag_recommendations($conn, $query);
+    // echo json_encode($result);
+    
+    // For now, return example response
+    echo json_encode([
+        'success' => true,
+        'message' => 'RAG API integration ready. Call get_rag_recommendations($conn, $query) from your chat handler.',
+        'products' => []
+    ]);
+}
+?>

requirements.txt

@@ -0,0 +1,18 @@
+setuptools>=70.0.0
+wheel
+fastapi==0.104.1
+uvicorn==0.24.0
+python-dotenv==1.0.0
+openai>=1.0.0
+pydantic>=2.10.0
+pydantic-settings>=2.3.0
+requests==2.31.0
+pymysql==1.1.0
+numpy>=2.4.0
+langchain>=0.1.0
+langchain-community>=0.0.10
+faiss-cpu>=1.13.0
+sentence-transformers>=2.2.2
+python-multipart==0.0.6
+cors==1.0.1
+python-json-logger>=2.0.0

start_rag.sh

@@ -0,0 +1,114 @@
+#!/bin/bash
+
+# RAG API Quick Start Script
+# Automatically sets up and starts the RAG API server
+
+set -e
+
+PROJECT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$PROJECT_DIR"
+
+echo "================================"
+echo "  RAG API Quick Start"
+echo "================================"
+echo ""
+
+# Check if Python is installed
+if ! command -v python3 &> /dev/null; then
+    echo "❌ Python3 is not installed. Please install Python 3.8+"
+    exit 1
+fi
+
+echo "✓ Python3 found: $(python3 --version)"
+echo ""
+
+# Create virtual environment if it doesn't exist
+if [ ! -d "venv" ]; then
+    echo "📦 Creating virtual environment..."
+    python3 -m venv venv
+    echo "✓ Virtual environment created"
+else
+    echo "✓ Virtual environment already exists"
+fi
+
+echo ""
+echo "🔧 Activating virtual environment..."
+source venv/bin/activate
+
+echo "✓ Virtual environment activated"
+echo ""
+
+# Check if requirements are installed
+echo "📚 Installing/updating requirements..."
+pip install -q -r requirements.txt
+echo "✓ Requirements installed"
+
+echo ""
+echo "⚙️  Checking environment variables..."
+
+# Check if .env exists
+if [ ! -f ".env" ]; then
+    echo "❌ .env file not found!"
+    echo ""
+    echo "Please create .env with:"
+    echo "  NVIDIA_API_KEY=nvapi-your-key-here"
+    echo "  NVIDIA_MODEL=mistralai/mistral-medium-3.5-128b"
+    echo "  RAG_API_URL=http://localhost:8004"
+    echo ""
+    echo "  Get NVIDIA API key from: https://build.nvidia.com/"
+    echo ""
+    echo "  1. Copy template: cp .env.example .env"
+    echo "  2. Edit .env with your NVIDIA API key"
+    echo "  3. Run this script again"
+    exit 1
+else
+    echo "✓ .env file found"
+fi
+
+# Check if NVIDIA_API_KEY is set
+if ! grep -q "NVIDIA_API_KEY=" .env || grep "NVIDIA_API_KEY=nvapi-" .env | grep -q "your-key"; then
+    echo "❌ NVIDIA_API_KEY not configured in .env"
+    echo ""
+    echo "Please edit .env and add your actual NVIDIA API key:"
+    echo "  nano .env"
+    echo ""
+    echo "Get key from: https://build.nvidia.com/"
+    exit 1
+fi
+
+echo "✓ Environment configured"
+echo ""
+
+# Final checks
+echo "🧪 Running health checks..."
+python3 -c "
+from sentence_transformers import SentenceTransformer
+print('✓ Sentence-Transformers OK')
+" || {
+    echo "❌ Failed to import sentence-transformers"
+    exit 1
+}
+
+python3 -c "
+import faiss
+print('✓ FAISS OK')
+" || {
+    echo "❌ Failed to import FAISS"
+    exit 1
+}
+
+echo ""
+echo "================================"
+echo "  ✅ All checks passed!"
+echo "================================"
+echo ""
+echo "🚀 Starting RAG API Server..."
+echo ""
+echo "   Server will run on: http://0.0.0.0:8004"
+echo "   API Docs: http://localhost:8004/docs"
+echo ""
+echo "   Press Ctrl+C to stop the server"
+echo ""
+
+# Start the server
+python3 rag_api.py