fyp

app/ai/agent/brain.py

@@ -101,7 +101,7 @@ async def generate_localized_response(
     max_retries: int = 3
 ) -> str:
     """
-    Generate a response using LLM in the specified language with retry logic.
+    Generate a response using LLM in the specified language with retry logic and caching.
 
     This replaces hardcoded messages with dynamic LLM-generated responses
     that respect the user's language preference.
@@ -125,6 +125,13 @@ async def generate_localized_response(
         "Super ! 🎉 Votre annonce a été enregistrée avec succès !"
     """
     import asyncio
+    from app.ai.agent.message_cache import get_cached_message, cache_message
+
+    # Check cache first (reduces LLM calls for common messages)
+    cached = get_cached_message(context, language, tone, max_length)
+    if cached:
+        logger.debug("Using cached message", language=language, context=context[:30])
+        return cached
 
     language_names = {
         "en": "English",
@@ -164,24 +171,22 @@ Response:"""
     for attempt in range(max_retries):
         try:
             response = await brain_llm.ainvoke([HumanMessage(content=prompt)])
-            return response.content.strip().strip('"')
+            generated_message = response.content.strip().strip('"')
+
+            # Cache the generated message
+            cache_message(context, language, tone, max_length, generated_message)
+
+            return generated_message
         except Exception as e:
             logger.warning(
                 f"Failed to generate localized response (attempt {attempt + 1}/{max_retries}): {e}"
             )
 
-            # If this was the last attempt, give up
+            # If this was the last attempt, use generic English fallback
             if attempt == max_retries - 1:
-                logger.error(f"All {max_retries} attempts failed. Using fallback response.")
-                # Generate a basic fallback in the requested language if possible
-                fallback_messages = {
-                    "en": "I'm here to help! How can I assist you?",
-                    "fr": "Je suis là pour vous aider ! Comment puis-je vous assister ?",
-                    "es": "¡Estoy aquí para ayudar! ¿Cómo puedo asistirte?",
-                    "pt": "Estou aqui para ajudar! Como posso ajudá-lo?",
-                    "ar": "أنا هنا للمساعدة! كيف يمكنني مساعدتك؟",
-                }
-                return fallback_messages.get(language, fallback_messages["en"])
+                logger.error(f"All {max_retries} attempts failed. Using generic English fallback.")
+                # Generic English fallback only (as per user's preference)
+                return "I'm here to help! How can I assist you?"
 
             # Wait before retrying (exponential backoff: 0.5s, 1s, 2s)
             await asyncio.sleep(0.5 * (2 ** attempt))

app/ai/agent/message_cache.py

@@ -0,0 +1,135 @@
+# app/ai/agent/message_cache.py
+"""
+Simple in-memory cache for frequently used LLM-generated messages.
+Reduces latency and costs by caching common responses per language.
+"""
+
+import hashlib
+from datetime import datetime, timedelta
+from typing import Optional, Dict
+from structlog import get_logger
+
+logger = get_logger(__name__)
+
+
+class MessageCache:
+    """
+    In-memory cache for LLM-generated messages.
+
+    Cache key format: hash(context + language + tone + max_length)
+    TTL: 24 hours (messages are regenerated daily for freshness)
+    """
+
+    def __init__(self, ttl_hours: int = 24):
+        self._cache: Dict[str, Dict] = {}
+        self._ttl = timedelta(hours=ttl_hours)
+        logger.info("MessageCache initialized", ttl_hours=ttl_hours)
+
+    def _generate_key(self, context: str, language: str, tone: str, max_length: str) -> str:
+        """Generate cache key from parameters."""
+        combined = f"{context}|{language}|{tone}|{max_length}"
+        return hashlib.md5(combined.encode()).hexdigest()
+
+    def get(
+        self,
+        context: str,
+        language: str,
+        tone: str,
+        max_length: str
+    ) -> Optional[str]:
+        """
+        Retrieve cached message if available and not expired.
+
+        Returns:
+            Cached message or None if not found/expired
+        """
+        key = self._generate_key(context, language, tone, max_length)
+
+        if key not in self._cache:
+            return None
+
+        entry = self._cache[key]
+
+        # Check if expired
+        if datetime.utcnow() > entry["expires_at"]:
+            del self._cache[key]
+            logger.debug("Cache entry expired", key=key[:8])
+            return None
+
+        logger.debug("Cache hit", key=key[:8], language=language)
+        return entry["message"]
+
+    def set(
+        self,
+        context: str,
+        language: str,
+        tone: str,
+        max_length: str,
+        message: str
+    ):
+        """Store message in cache with expiration."""
+        key = self._generate_key(context, language, tone, max_length)
+
+        self._cache[key] = {
+            "message": message,
+            "created_at": datetime.utcnow(),
+            "expires_at": datetime.utcnow() + self._ttl,
+            "language": language,
+        }
+
+        logger.debug("Cache entry created", key=key[:8], language=language)
+
+    def clear(self):
+        """Clear all cache entries."""
+        count = len(self._cache)
+        self._cache.clear()
+        logger.info("Cache cleared", entries_removed=count)
+
+    def get_stats(self) -> Dict:
+        """Get cache statistics."""
+        total = len(self._cache)
+        expired = sum(
+            1 for entry in self._cache.values()
+            if datetime.utcnow() > entry["expires_at"]
+        )
+
+        return {
+            "total_entries": total,
+            "expired_entries": expired,
+            "active_entries": total - expired,
+        }
+
+
+# Global cache instance
+_message_cache = MessageCache(ttl_hours=24)
+
+
+def get_cached_message(
+    context: str,
+    language: str,
+    tone: str,
+    max_length: str
+) -> Optional[str]:
+    """Get message from cache."""
+    return _message_cache.get(context, language, tone, max_length)
+
+
+def cache_message(
+    context: str,
+    language: str,
+    tone: str,
+    max_length: str,
+    message: str
+):
+    """Store message in cache."""
+    _message_cache.set(context, language, tone, max_length, message)
+
+
+def clear_message_cache():
+    """Clear all cached messages."""
+    _message_cache.clear()
+
+
+def get_cache_stats() -> Dict:
+    """Get cache statistics."""
+    return _message_cache.get_stats()