⚡ Bolt: Cache AI recommendations in Jules Engine

.jules/bolt.md

@@ -0,0 +1,3 @@
+## 2025-05-15 - [LRU Cache for AI Recommendations]
+**Learning:** LLM API calls are a major bottleneck (several seconds per request). Implementing `functools.lru_cache` provides massive performance gains for identical requests. However, Pydantic models and dictionaries are not hashable and cannot be used directly as cache keys.
+**Action:** When implementing `lru_cache` for functions involving complex objects, use an internal helper function that accepts primitive, hashable types (strings, ints) to form the cache key.

backend/benchmark_jules.py

@@ -0,0 +1,64 @@
+import time
+import sys
+import os
+from unittest.mock import MagicMock
+
+# Ensure we can import from the backend directory
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+import jules_engine
+from models import UserScan, SHOPIFY_INVENTORY
+
+def benchmark():
+    print("--- ⚡ JULES ENGINE PERFORMANCE BENCHMARK ---")
+
+    # Mock the generative model to avoid real API calls and simulate latency
+    original_model = jules_engine.model
+    mock_model = MagicMock()
+
+    def mock_generate_content(prompt):
+        time.sleep(0.5) # Simulate 500ms LLM latency
+        mock_response = MagicMock()
+        mock_response.text = "Mocked Luxury Advice: Elegant and Fluid."
+        return mock_response
+
+    mock_model.generate_content.side_effect = mock_generate_content
+    jules_engine.model = mock_model
+
+    # Prepare test data
+    user_data = UserScan(
+        user_id="test_user",
+        token="test_token",
+        waist=70.0,
+        event_type="Gala"
+    )
+
+    # Ensure garment has required keys (temporarily for this test if not fixed yet)
+    garment = SHOPIFY_INVENTORY["BALMAIN_SS26_SLIM"].copy()
+    if 'drape' not in garment:
+        garment['drape'] = "Architectural"
+    if 'elasticity' not in garment:
+        garment['elasticity'] = "High-Recovery"
+
+    print("\n1. Initial call (Cold Cache):")
+    start = time.perf_counter()
+    advice1 = jules_engine.get_jules_advice(user_data, garment)
+    end = time.perf_counter()
+    print(f"Time: {(end - start) * 1000:.2f}ms")
+
+    print("\n2. Second call with same data (Should be cached if implemented):")
+    start = time.perf_counter()
+    advice2 = jules_engine.get_jules_advice(user_data, garment)
+    end = time.perf_counter()
+    print(f"Time: {(end - start) * 1000:.2f}ms")
+
+    # Restore original model
+    jules_engine.model = original_model
+
+    if advice1 == advice2:
+        print("\n[SUCCESS] Responses match.")
+    else:
+        print("\n[ERROR] Responses do not match.")
+
+if __name__ == "__main__":
+    benchmark()

backend/jules_engine.py

@@ -1,6 +1,7 @@
 import os
 import google.generativeai as genai
 from dotenv import load_dotenv
+from functools import lru_cache
 
 # Load .env from the same directory or current directory
 load_dotenv()
@@ -17,26 +18,18 @@
 genai.configure(api_key=api_key)
 model = genai.GenerativeModel('gemini-1.5-flash')
 
-def get_jules_advice(user_data, garment):
+@lru_cache(maxsize=128)
+def _get_jules_advice_cached(event_type: str, garment_name: str, drape: str, elasticity: str):
     """
-    Generates an emotional styling tip without mentioning body numbers or sizes.
+    Internal cached function using only hashable types for the cache key.
     """
-    # garment is a dict (from GARMENT_DB) or Garment object.
-    # The prompt usage implies dict access: garment['name']
-
-    # Handle both dict and Pydantic model
-    if hasattr(garment, 'dict'):
-        garment_data = garment.dict()
-    else:
-        garment_data = garment
-
     prompt = f"""
     You are 'Jules', a high-end fashion consultant at Galeries Lafayette.
-    A client is interested in the '{garment_data['name']}' for a {user_data.event_type}.
+    A client is interested in the '{garment_name}' for a {event_type}.
 
     Technical Context:
-    - Fabric Drape: {garment_data['drape']}
-    - Fabric Elasticity: {garment_data['elasticity']}
+    - Fabric Drape: {drape}
+    - Fabric Elasticity: {elasticity}
 
     Task:
     Explain why this garment is the perfect choice for their silhouette based
@@ -51,3 +44,27 @@ def get_jules_advice(user_data, garment):
 
     response = model.generate_content(prompt)
     return response.text
+
+def get_jules_advice(user_data, garment):
+    """
+    Generates an emotional styling tip without mentioning body numbers or sizes.
+    Leverages caching for performance.
+    """
+    # Handle both dict and Pydantic model
+    if hasattr(garment, 'get'):
+        # It's a dict
+        garment_data = garment
+    elif hasattr(garment, 'dict'):
+        # It's a Pydantic model
+        garment_data = garment.dict()
+    else:
+        # Fallback
+        garment_data = garment
+
+    # Use the cached helper to avoid redundant LLM calls
+    return _get_jules_advice_cached(
+        user_data.event_type,
+        garment_data.get('name', 'Luxury Item'),
+        garment_data.get('drape', 'Fluid'),
+        garment_data.get('elasticity', 'Comfortable')
+    )

backend/models.py

@@ -25,7 +25,9 @@ class Garment(BaseModel):
         "stretch_factor": 1.15,
         "stock": 12,
         "price": "1.290 €",
-        "variant_id": "gid://shopify/ProductVariant/445566"
+        "variant_id": "gid://shopify/ProductVariant/445566",
+        "drape": "Architectural",
+        "elasticity": "Medium-High Recovery"
     },
     "LEVIS_510_STRETCH": {
         "id": "LEVIS_510_STRETCH",
@@ -34,7 +36,9 @@ class Garment(BaseModel):
         "stretch_factor": 1.10,
         "stock": 45,
         "price": "110 €",
-        "variant_id": "gid://shopify/ProductVariant/778899"
+        "variant_id": "gid://shopify/ProductVariant/778899",
+        "drape": "Classic Slim",
+        "elasticity": "Moderate Comfort"
     }
 }
 

backend/tests/test_main.py

@@ -1,14 +1,17 @@
 import pytest
+import hmac
+import hashlib
+import time
 from fastapi.testclient import TestClient
-from backend.main import app
+from backend.main import app, SECRET_KEY
 
 client = TestClient(app)
 
-def test_recommend_garment_engine_failure(monkeypatch):
+def test_recommend_garment_engine_fallback(monkeypatch):
     """
     Test that the /api/recommend endpoint correctly handles failures
-    from the Jules AI engine (get_jules_advice) and returns a 503
-    Service Unavailable with a gracefully structured JSON error.
+    from the Jules AI engine (get_jules_advice) and returns a 200
+    with a fallback recommendation string.
     """
     # 1. Mock the get_jules_advice function to raise an exception
     def mock_get_jules_advice(*args, **kwargs):
@@ -17,22 +20,25 @@ def mock_get_jules_advice(*args, **kwargs):
     # Use monkeypatch to replace the real function with our mock
     monkeypatch.setattr("backend.main.get_jules_advice", mock_get_jules_advice)
 
-    # 2. Prepare the request payload
+    # 2. Prepare the request payload with valid auth
+    user_id = "LAFAYETTE_USER"
+    ts = str(int(time.time()))
+    sig = hmac.new(SECRET_KEY.encode(), f"{user_id}:{ts}".encode(), hashlib.sha256).hexdigest()
+    token = f"{ts}.{sig}"
+
     payload = {
-        "height": 175.0,
-        "weight": 68.0,
+        "user_id": user_id,
+        "token": token,
+        "waist": 70.0,
         "event_type": "Gala"
     }
 
     # 3. Send the POST request to the endpoint
     response = client.post("/api/recommend", json=payload)
 
     # 4. Assertions
-    assert response.status_code == 503
+    assert response.status_code == 200
 
     data = response.json()
-    assert data == {
-        "status": "error",
-        "code": 503,
-        "message": "Jules AI Engine is currently recalibrating or unavailable. Please try again."
-    }
+    # It should contain the fallback styling advice
+    assert "Divineo confirmado con" in data["styling_advice"]