Add Semantic Caching and CrewAI Config

backend/apps/ai/admin.py

@@ -4,6 +4,7 @@
 
 from apps.ai.models.chunk import Chunk
 from apps.ai.models.context import Context
+from apps.ai.models.semantic_cache import SemanticCache
 
 
 class ChunkAdmin(admin.ModelAdmin):
@@ -32,5 +33,20 @@ class ContextAdmin(admin.ModelAdmin):
     search_fields = ("content", "source")
 
 
+class SemanticCacheAdmin(admin.ModelAdmin):
+    """Admin for SemanticCache model."""
+
+    list_display = (
+        "confidence",
+        "id",
+        "intent",
+        "nest_created_at",
+        "query_text",
+    )
+    list_filter = ("intent",)
+    search_fields = ("query_text", "response_text")
+
+
 admin.site.register(Chunk, ChunkAdmin)
 admin.site.register(Context, ContextAdmin)
+admin.site.register(SemanticCache, SemanticCacheAdmin)

backend/apps/ai/common/crewai_config.py

@@ -0,0 +1,12 @@
+"""CrewAI assistant configuration."""
+
+from dataclasses import dataclass
+
+
+@dataclass
+class CrewAIConfig:
+    """CrewAI assistant configuration."""
+
+    semantic_cache_enabled: bool = True
+    semantic_cache_similarity_threshold: float = 0.95
+    semantic_cache_ttl_seconds: int = 86400  # 24 hours

backend/apps/ai/flows/assistant.py

@@ -14,6 +14,7 @@
 from apps.ai.flows.collaborative import handle_collaborative_query
 from apps.ai.query_analyzer import analyze_query
 from apps.ai.router import route
+from apps.ai.semantic_cache import get_cached_response, store_cached_response
 from apps.common.open_ai import OpenAi
 from apps.slack.constants import (
     OWASP_COMMUNITY_CHANNEL_ID,
@@ -265,6 +266,13 @@ def process_query(  # noqa: PLR0911
                     is_channel_suggestion=True,
                 )
 
+        # Check semantic cache
+        try:
+            if (cached := get_cached_response(query)) is not None:
+                return cached
+        except Exception:
+            logger.exception("Semantic cache lookup failed, proceeding without cache")
+
         # Step 2: Analyze query complexity before routing
         try:
             query_analysis = analyze_query(query)
@@ -283,7 +291,15 @@ def process_query(  # noqa: PLR0911
         # Step 3: Use collaborative flow for complex query
         if not query_analysis["is_simple"] and len(query_analysis["sub_queries"]) > 1:
             try:
-                return handle_collaborative_query(query, query_analysis["sub_queries"])
+                if response := handle_collaborative_query(query, query_analysis["sub_queries"]):
+                    try:
+                        store_cached_response(
+                            query=query,
+                            response=response,
+                        )
+                    except Exception:
+                        logger.exception("Failed to store semantic cache entry")
+                    return response
             except Exception:
                 logger.exception(
                     "Collaborative flow failed, falling back to single agent: %s", query
@@ -383,11 +399,22 @@ def process_query(  # noqa: PLR0911
         agent = agent_factory()
 
         # Step 8: Execute task with agent
-        return execute_task(agent, query)
+        if response := execute_task(agent, query):
+            try:
+                store_cached_response(
+                    query=query,
+                    response=response,
+                    intent=intent,
+                    confidence=confidence,
+                )
+            except Exception:
+                logger.exception("Failed to store semantic cache entry")
 
     except Exception:
         logger.exception("Failed to process query: %s", query)
         return get_fallback_response()
+    else:
+        return response
 
 
 def execute_task(

backend/apps/ai/migrations/0011_semanticcache.py

@@ -0,0 +1,43 @@
+# Generated by Django 6.0.3 on 2026-04-13 14:06
+
+import pgvector.django.vector
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("ai", "0010_alter_context_unique_together"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="SemanticCache",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True, primary_key=True, serialize=False, verbose_name="ID"
+                    ),
+                ),
+                ("nest_created_at", models.DateTimeField(auto_now_add=True)),
+                ("nest_updated_at", models.DateTimeField(auto_now=True)),
+                ("confidence", models.FloatField(default=0.0, verbose_name="Confidence")),
+                (
+                    "intent",
+                    models.CharField(blank=True, default="", max_length=50, verbose_name="Intent"),
+                ),
+                (
+                    "query_embedding",
+                    pgvector.django.vector.VectorField(
+                        dimensions=1536, verbose_name="Query Embedding"
+                    ),
+                ),
+                ("query_text", models.TextField(verbose_name="Query Text")),
+                ("response_text", models.TextField(verbose_name="Response Text")),
+            ],
+            options={
+                "verbose_name": "Semantic Cache",
+                "db_table": "ai_semantic_cache",
+            },
+        ),
+    ]

backend/apps/ai/models/__init__.py

@@ -1 +1,2 @@
 from .chunk import Chunk
+from .semantic_cache import SemanticCache

backend/apps/ai/models/chunk.py

@@ -7,6 +7,8 @@
 from apps.common.models import BulkSaveModel, TimestampedModel
 from apps.common.utils import truncate
 
+EMBEDDING_DIMENSIONS = 1536
+
 
 class Chunk(TimestampedModel):
     """AI Chunk model for storing text chunks with embeddings."""
@@ -19,7 +21,7 @@ class Meta:
         unique_together = ("context", "text")
 
     context = models.ForeignKey(Context, on_delete=models.CASCADE, related_name="chunks")
-    embedding = VectorField(verbose_name="Embedding", dimensions=1536)
+    embedding = VectorField(verbose_name="Embedding", dimensions=EMBEDDING_DIMENSIONS)
     text = models.TextField(verbose_name="Text")
 
     def __str__(self):

backend/apps/ai/models/semantic_cache.py

@@ -0,0 +1,121 @@
+"""AI app semantic cache model."""
+
+import logging
+from datetime import UTC, datetime, timedelta
+
+from django.db import models
+from pgvector.django import VectorField
+from pgvector.django.functions import CosineDistance
+
+from apps.ai.models.chunk import EMBEDDING_DIMENSIONS
+from apps.common.models import TimestampedModel
+from apps.common.utils import truncate
+
+logger = logging.getLogger(__name__)
+
+
+# TODO(rudransh-shrivastava): Add Cache Invalidation cron job.
+class SemanticCache(TimestampedModel):
+    """Semantic cache model for storing query-response pairs with embeddings."""
+
+    class Meta:
+        """Model options."""
+
+        db_table = "ai_semantic_cache"
+        verbose_name = "Semantic Cache"
+
+    confidence = models.FloatField(verbose_name="Confidence", default=0.0)
+    intent = models.CharField(verbose_name="Intent", blank=True, default="", max_length=50)
+    query_embedding = VectorField(verbose_name="Query Embedding", dimensions=EMBEDDING_DIMENSIONS)
+    query_text = models.TextField(verbose_name="Query Text")
+    response_text = models.TextField(verbose_name="Response Text")
+
+    def __str__(self):
+        """Human readable representation."""
+        return f"SemanticCache {self.id}: {truncate(self.query_text, 50)}"
+
+    @staticmethod
+    def get_cached_response(
+        query: str,
+        *,
+        similarity_threshold: float = 0.95,
+        ttl_seconds: int = 86400,
+    ) -> str | None:
+        """Look up semantically similar cached response.
+
+        Args:
+            query: User query text.
+            similarity_threshold: Minimum cosine similarity (0.0-1.0).
+            ttl_seconds: Maximum age of cached entries in seconds.
+
+        Returns:
+            Cached response string if found, None otherwise.
+
+        """
+        from apps.ai.embeddings.factory import get_embedder  # noqa: PLC0415
+
+        ttl_cutoff = datetime.now(UTC) - timedelta(seconds=ttl_seconds)
+        max_distance = 1.0 - similarity_threshold
+
+        result = (
+            SemanticCache.objects.filter(nest_created_at__gte=ttl_cutoff)
+            .annotate(
+                distance=CosineDistance("query_embedding", get_embedder().embed_query(query))
+            )
+            .filter(distance__lte=max_distance)
+            .order_by("distance")
+            .first()
+        )
+
+        if result is not None:
+            logger.info(
+                "Semantic cache hit",
+                extra={
+                    "cache_id": result.id,
+                    "distance": float(result.distance),
+                    "query_preview": query[:100],
+                },
+            )
+            return result.response_text
+
+        return None
+
+    @staticmethod
+    def store_response(
+        query: str,
+        response: str,
+        intent: str = "",
+        confidence: float = 0.0,
+    ) -> "SemanticCache":
+        """Store query-response pair in semantic cache.
+
+        Args:
+            query: Original query text.
+            response: Generated response text.
+            intent: Classified intent for the query.
+            confidence: Router confidence score.
+
+        Returns:
+            Created SemanticCache instance.
+
+        """
+        from apps.ai.embeddings.factory import get_embedder  # noqa: PLC0415
+
+        entry = SemanticCache(
+            query_text=query,
+            query_embedding=get_embedder().embed_query(query),
+            response_text=response,
+            intent=intent,
+            confidence=confidence,
+        )
+        entry.save()
+
+        logger.info(
+            "Semantic cache stored",
+            extra={
+                "cache_id": entry.id,
+                "intent": intent,
+                "query_preview": query[:100],
+            },
+        )
+        return entry

backend/apps/ai/semantic_cache.py

@@ -0,0 +1,56 @@
+"""Semantic cache service for AI query responses."""
+
+from apps.ai.common.crewai_config import CrewAIConfig
+from apps.ai.models.semantic_cache import SemanticCache
+
+_config = CrewAIConfig()
+
+
+def get_cached_response(query: str) -> str | None:
+    """Look up semantically similar cached response.
+
+    Args:
+        query: User query text.
+
+    Returns:
+        Cached response string if found within similarity threshold and TTL,
+        None otherwise.
+
+    """
+    if not _config.semantic_cache_enabled:
+        return None
+
+    return SemanticCache.get_cached_response(
+        query,
+        similarity_threshold=_config.semantic_cache_similarity_threshold,
+        ttl_seconds=_config.semantic_cache_ttl_seconds,
+    )
+
+
+def store_cached_response(
+    query: str,
+    response: str,
+    intent: str = "",
+    confidence: float = 0.0,
+) -> SemanticCache | None:
+    """Store query-response pair in semantic cache.
+
+    Args:
+        query: Original query text.
+        response: Generated response text.
+        intent: Classified intent for the query.
+        confidence: Router confidence score.
+
+    Returns:
+        Created SemanticCache instance.
+
+    """
+    if not _config.semantic_cache_enabled:
+        return None
+
+    return SemanticCache.store_response(
+        query=query,
+        response=response,
+        intent=intent,
+        confidence=confidence,
+    )

backend/tests/unit/apps/ai/common/crewai_config_test.py

@@ -0,0 +1,25 @@
+"""Tests for CrewAI configuration."""
+
+import math
+
+from apps.ai.common.crewai_config import CrewAIConfig
+
+
+class TestCrewAIConfig:
+    def test_default_values(self):
+        config = CrewAIConfig()
+
+        assert config.semantic_cache_enabled is True
+        assert math.isclose(config.semantic_cache_similarity_threshold, 0.95)
+        assert config.semantic_cache_ttl_seconds == 86400
+
+    def test_custom_values(self):
+        config = CrewAIConfig(
+            semantic_cache_enabled=False,
+            semantic_cache_similarity_threshold=0.8,
+            semantic_cache_ttl_seconds=3600,
+        )
+
+        assert config.semantic_cache_enabled is False
+        assert math.isclose(config.semantic_cache_similarity_threshold, 0.8)
+        assert config.semantic_cache_ttl_seconds == 3600