perf: cache identical analyze requests (imDarshanGK#140)

* perf: cache identical analyze requests

* fix: align analyze cache contract with issue

---------

Co-authored-by: Darshan G K <122042809+imDarshanGK@users.noreply.github.com>

Author: saurabhhhcodes

backend/app/config.py

@@ -53,6 +53,7 @@ class Settings:
     rate_limit_window_seconds: int = _int_env("RATE_LIMIT_WINDOW_SECONDS", 60)
     cache_enabled: bool = _bool_env("CACHE_ENABLED", True)
     cache_ttl_seconds: int = _int_env("CACHE_TTL_SECONDS", 300)
+    cache_max_entries: int = _int_env("CACHE_MAX_ENTRIES", 100)
     redis_url: str | None = os.getenv("REDIS_URL")
     sentry_dsn: str | None = os.getenv("SENTRY_DSN")
     sentry_traces_sample_rate: float = _float_env("SENTRY_TRACES_SAMPLE_RATE", 0.0)

backend/app/main.py

@@ -103,6 +103,16 @@ async def add_process_time_header(request: Request, call_next):
     return response
 
 
+@app.middleware("http")
+async def add_cache_header(request: Request, call_next):
+    response = await call_next(request)
+
+    if request.url.path == "/analyze/" and request.method == "POST":
+        response.headers.setdefault("X-Cache", "MISS")
+
+    return response
+
+
 # ── Routers ───────────────────────────────────────────────────────────────────
 app.include_router(explanation.router, prefix="/explanation", tags=["Explanation"])
 app.include_router(debugging.router,   prefix="/debugging",   tags=["Debugging"])

backend/app/routers/analyze.py

@@ -1,10 +1,21 @@
 """Full analysis router — POST /analyze/"""
-from fastapi import APIRouter
+from fastapi import APIRouter, Response
 from ..schemas import CodeRequest, AnalyzeResponse
+from ..services.cache import cache
 from ..services.code_assistant import full_analysis
 
 router = APIRouter()
 
 @router.post("/", response_model=AnalyzeResponse, summary="Run full analysis (explain + debug + suggest)")
-async def analyze(req: CodeRequest):
-    return full_analysis(req.code, req.language)
+async def analyze(req: CodeRequest, response: Response):
+    cache_input = f"{req.language or 'auto'}\n{req.code}"
+    cached_payload = cache.get("analyze:v1", cache_input)
+
+    if cached_payload is not None:
+        response.headers["X-Cache"] = "HIT"
+        return cached_payload
+
+    payload = full_analysis(req.code, req.language)
+    cache.set("analyze:v1", cache_input, payload)
+    response.headers["X-Cache"] = "MISS"
+    return payload

backend/app/services/cache.py

@@ -2,6 +2,7 @@
 import json
 import logging
 import time
+from collections import OrderedDict
 from threading import Lock
 
 from ..config import settings
@@ -11,7 +12,7 @@
 
 class AppCache:
     def __init__(self):
-        self._memory_store: dict[str, tuple[float, dict]] = {}
+        self._memory_store: OrderedDict[str, tuple[float, dict]] = OrderedDict()
         self._memory_lock = Lock()
         self._redis_client = None
         self._backend = "memory"
@@ -30,7 +31,7 @@ def backend(self) -> str:
         return self._backend
 
     def _make_key(self, namespace: str, code: str) -> str:
-        digest = hashlib.sha256(code.encode("utf-8")).hexdigest()
+        digest = hashlib.md5(code.encode("utf-8")).hexdigest()
         return f"ai-assistant:{namespace}:{digest}"
 
     def get(self, namespace: str, code: str) -> dict | None:
@@ -57,6 +58,7 @@ def get(self, namespace: str, code: str) -> dict | None:
                 self._memory_store.pop(key, None)
                 return None
 
+            self._memory_store.move_to_end(key)
             return payload
 
     def set(self, namespace: str, code: str, payload: dict) -> None:
@@ -74,6 +76,14 @@ def set(self, namespace: str, code: str, payload: dict) -> None:
         expires_at = time.time() + settings.cache_ttl_seconds
         with self._memory_lock:
             self._memory_store[key] = (expires_at, payload)
+            self._memory_store.move_to_end(key)
+
+            while len(self._memory_store) > settings.cache_max_entries:
+                self._memory_store.popitem(last=False)
+
+    def clear_memory(self) -> None:
+        with self._memory_lock:
+            self._memory_store.clear()
 
 
 cache = AppCache()

backend/tests/test_endpoints.py

@@ -553,6 +553,60 @@ def test_full_analyze():
     assert d["provider"] == "rule-based"
     assert d["analysis_time_ms"] is not None
 
+def test_full_analyze_uses_cache_for_identical_inputs():
+    from app.main import _request_counts
+    from app.services.cache import cache
+
+    _request_counts.clear()
+    cache.clear_memory()
+    payload = {"code": PYTHON_BUGGY, "language": "python"}
+
+    first = client.post("/analyze/", json=payload)
+    second = client.post("/analyze/", json=payload)
+
+    assert first.status_code == 200
+    assert second.status_code == 200
+    assert first.headers["X-Cache"] == "MISS"
+    assert second.headers["X-Cache"] == "HIT"
+    assert second.json() == first.json()
+    _request_counts.clear()
+
+def test_analyze_cache_expires(monkeypatch):
+    from app.services import cache as cache_module
+    from app.services.cache import cache
+
+    cache.clear_memory()
+    payload = {"code": PYTHON_BUGGY, "language": "python"}
+    start = 1_700_000_000
+
+    monkeypatch.setattr(cache_module.time, "time", lambda: start)
+    first = client.post("/analyze/", json=payload)
+
+    monkeypatch.setattr(cache_module.time, "time", lambda: start + 301)
+    second = client.post("/analyze/", json=payload)
+
+    assert first.status_code == 200
+    assert second.status_code == 200
+    assert first.headers["X-Cache"] == "MISS"
+    assert second.headers["X-Cache"] == "MISS"
+    cache.clear_memory()
+
+def test_memory_cache_evicts_least_recently_used_entries():
+    from app.services.cache import cache
+
+    cache.clear_memory()
+
+    for index in range(100):
+        cache.set("test", f"item-{index}", {"index": index})
+
+    assert cache.get("test", "item-0") == {"index": 0}
+    cache.set("test", "item-100", {"index": 100})
+
+    assert cache.get("test", "item-1") is None
+    assert cache.get("test", "item-0") == {"index": 0}
+    assert cache.get("test", "item-100") == {"index": 100}
+    cache.clear_memory()
+
 def test_full_analyze_all_languages():
     for code, lang in [
         (JS_CODE, "javascript"),