feat: implement Redis-first refresh token storage with Supabase fallback

auth/constants.py

@@ -37,3 +37,9 @@ REFRESH_COOKIE_NAME    = "refresh_token"
 # Scope the cookie to the auth sub-path so it is NOT sent to /api/materials etc.
 REFRESH_COOKIE_PATH    = "/api/auth"
 REFRESH_COOKIE_MAX_AGE = REFRESH_TOKEN_EXPIRE_DAYS * 24 * 3600  # seconds
+
+# ── Redis Auth Keys & TTLs ─────────────────────────────────────────────────────
+REFRESH_TOKEN_KEY_PREFIX = "rt:"
+USER_REFRESH_TOKENS_KEY_PREFIX = "user_rts:"
+REFRESH_TOKEN_REDIS_TTL = REFRESH_TOKEN_EXPIRE_DAYS * 86400  # seconds
+

auth/refresh_token_store.py

@@ -1,9 +1,24 @@
 """
-Stateful refresh-token store.
+Stateful refresh-token store — Redis-first, Supabase fallback.
 
-Wraps the `refresh_tokens` Supabase table with simple CRUD helpers.
-All functions are synchronous and use the existing `_table_supabase`
-helper from `store.py`, so they get the same dev-mode fallback behaviour.
+Strategy
+--------
+* LOGIN  (save_refresh_token):
+    Write to Redis (primary, fast reads) AND Supabase (audit log).
+    Redis TTL = REFRESH_TOKEN_EXPIRE_DAYS.
+
+* REFRESH (get_refresh_token):
+    Read from Redis only (<5 ms).
+    If Redis miss (e.g. first deploy after adding Redis), fall back to Supabase
+    and repopulate Redis so subsequent reads are fast.
+
+* REVOKE (revoke_refresh_token / revoke_all_user_tokens):
+    Delete / mark revoked in Redis first, then mirror to Supabase.
+
+Redis key schema
+----------------
+    rt:{token_hash}          → Hash  {user_id, expires_at, revoked}   TTL=30d
+    user_rts:{user_id}       → Set   of token_hash strings             TTL=30d
 
 Table DDL (run once in the Supabase SQL editor):
 
@@ -24,38 +39,98 @@ from datetime import datetime, timedelta, timezone
 from typing import Optional
 
 from src.store import _table_supabase, _robust_execute
-from src.auth.constants import REFRESH_TOKEN_EXPIRE_DAYS
+from src.auth.constants import (
+    REFRESH_TOKEN_EXPIRE_DAYS,
+    REFRESH_TOKEN_KEY_PREFIX,
+    USER_REFRESH_TOKENS_KEY_PREFIX,
+    REFRESH_TOKEN_REDIS_TTL,
+)
+from src.redis_client import get_redis
 
 logger = logging.getLogger(__name__)
 
 
+def _rt_key(token_hash: str) -> str:
+    return f"{REFRESH_TOKEN_KEY_PREFIX}{token_hash}"
+
+def _user_rts_key(user_id: str) -> str:
+    return f"{USER_REFRESH_TOKENS_KEY_PREFIX}{user_id}"
+
+
 def _now_utc() -> datetime:
     return datetime.now(timezone.utc)
 
 
+# ── Save ──────────────────────────────────────────────────────────────────────
+
 def save_refresh_token(user_id: str, token_hash: str) -> None:
-    """Persist a new (un-revoked) refresh token row for *user_id*."""
+    """
+    Persist a new (un-revoked) refresh token.
+
+    Writes to Redis (primary, fast reads) AND Supabase (audit log).
+    Called once at login — the extra Supabase write here is acceptable
+    because this path is only hit when the user actively signs in.
+    """
     expires_at = _now_utc() + timedelta(days=REFRESH_TOKEN_EXPIRE_DAYS)
+    expires_iso = expires_at.isoformat()
+
+    # 1. Redis — primary store
+    r = get_redis()
+    if r is not None:
+        try:
+            key = _rt_key(token_hash)
+            pipe = r.pipeline()
+            pipe.hset(key, mapping={
+                "user_id":    user_id,
+                "expires_at": expires_iso,
+                "revoked":    "0",
+            })
+            pipe.expire(key, REFRESH_TOKEN_REDIS_TTL)
+            # Track all hashes per user so revoke_all_user_tokens can find them
+            ukey = _user_rts_key(user_id)
+            pipe.sadd(ukey, token_hash)
+            pipe.expire(ukey, REFRESH_TOKEN_REDIS_TTL)
+            pipe.execute()
+        except Exception as e:
+            logger.warning("Redis save_refresh_token failed: %s", e)
+
+    # 2. Supabase — audit log / fallback
     try:
         _robust_execute(
             _table_supabase("refresh_tokens").insert({
-                "user_id": user_id,
+                "user_id":    user_id,
                 "token_hash": token_hash,
-                "expires_at": expires_at.isoformat(),
-                "revoked": False,
+                "expires_at": expires_iso,
+                "revoked":    False,
             })
         )
     except Exception as e:
-        logger.error("save_refresh_token failed: %s", e)
+        logger.error("Supabase save_refresh_token failed: %s", e)
         raise
 
 
+# ── Read ──────────────────────────────────────────────────────────────────────
+
 def get_refresh_token(token_hash: str) -> Optional[dict]:
     """
-    Look up a refresh token row by its hash.
+    Look up a refresh token by its hash.
 
-    Returns the raw DB row dict, or None if not found.
+    Reads from Redis first (<5 ms).  On a Redis miss, falls back to Supabase
+    and back-populates Redis so the next read is fast.
     """
+    r = get_redis()
+    if r is not None:
+        try:
+            key = _rt_key(token_hash)
+            data = r.hgetall(key)
+            if data:
+                # Normalise boolean — stored as "0"/"1" string
+                data["revoked"] = data.get("revoked", "0") == "1"
+                return data
+        except Exception as e:
+            logger.warning("Redis get_refresh_token failed: %s", e)
+
+    # Redis miss or unavailable — fall back to Supabase
     try:
         result = _robust_execute(
             _table_supabase("refresh_tokens")
@@ -64,15 +139,43 @@ def get_refresh_token(token_hash: str) -> Optional[dict]:
         )
         rows = result.data
         if isinstance(rows, list):
-            return rows[0] if rows else None
-        return rows or None
+            row = rows[0] if rows else None
+        else:
+            row = rows or None
+
+        # Back-populate Redis so subsequent reads are fast
+        if row and r is not None:
+            try:
+                key = _rt_key(token_hash)
+                pipe = r.pipeline()
+                pipe.hset(key, mapping={
+                    "user_id":    str(row["user_id"]),
+                    "expires_at": str(row.get("expires_at", "")),
+                    "revoked":    "1" if row.get("revoked") else "0",
+                })
+                pipe.expire(key, REFRESH_TOKEN_REDIS_TTL)
+                pipe.execute()
+            except Exception as cache_err:
+                logger.warning("Redis back-populate failed: %s", cache_err)
+
+        return row
     except Exception as e:
-        logger.error("get_refresh_token failed: %s", e)
+        logger.error("get_refresh_token Supabase fallback failed: %s", e)
         return None
 
 
+# ── Revoke single token ───────────────────────────────────────────────────────
+
 def revoke_refresh_token(token_hash: str) -> None:
-    """Mark a single token as revoked."""
+    """Mark a single token as revoked in Redis and Supabase."""
+    r = get_redis()
+    if r is not None:
+        try:
+            key = _rt_key(token_hash)
+            r.hset(key, "revoked", "1")
+        except Exception as e:
+            logger.warning("Redis revoke_refresh_token failed: %s", e)
+
     try:
         _robust_execute(
             _table_supabase("refresh_tokens")
@@ -80,11 +183,27 @@ def revoke_refresh_token(token_hash: str) -> None:
             .eq("token_hash", token_hash)
         )
     except Exception as e:
-        logger.error("revoke_refresh_token failed: %s", e)
+        logger.error("revoke_refresh_token Supabase failed: %s", e)
+
 
+# ── Revoke all tokens for a user ──────────────────────────────────────────────
 
 def revoke_all_user_tokens(user_id: str) -> None:
     """Revoke every active refresh token for *user_id* (logout-everywhere)."""
+    r = get_redis()
+    if r is not None:
+        try:
+            ukey = _user_rts_key(user_id)
+            hashes = r.smembers(ukey)
+            if hashes:
+                pipe = r.pipeline()
+                for h in hashes:
+                    pipe.hset(_rt_key(h), "revoked", "1")
+                pipe.delete(ukey)
+                pipe.execute()
+        except Exception as e:
+            logger.warning("Redis revoke_all_user_tokens failed: %s", e)
+
     try:
         _robust_execute(
             _table_supabase("refresh_tokens")
@@ -92,26 +211,27 @@ def revoke_all_user_tokens(user_id: str) -> None:
             .eq("user_id", user_id)
         )
     except Exception as e:
-        logger.error("revoke_all_user_tokens failed for %s: %s", user_id, e)
+        logger.error("revoke_all_user_tokens Supabase failed for %s: %s", user_id, e)
+
 
+# ── Validity check (unchanged — pure Python, no I/O) ─────────────────────────
 
 def is_token_valid(row: dict) -> bool:
     """
-    Return True if the DB row represents a currently-valid refresh token.
+    Return True if the row represents a currently-valid refresh token.
 
     Checks: row exists, not revoked, not expired.
+    Works with both Supabase row dicts and Redis hgetall dicts.
     """
     if not row:
         return False
-    if row.get("revoked"):
+    if row.get("revoked") in (True, "1", 1):
         return False
     expires_at_raw = row.get("expires_at")
     if not expires_at_raw:
         return False
-    # Supabase returns ISO-8601 strings; parse and compare.
     try:
         if isinstance(expires_at_raw, str):
-            # Handle both 'Z' suffix and '+00:00' offset
             expires_at_raw = expires_at_raw.replace("Z", "+00:00")
             expires_at = datetime.fromisoformat(expires_at_raw)
         else:

config.py

@@ -30,6 +30,7 @@ class Settings:
         or os.getenv("JWT_SECRET", "")
     )
     database_url: str = os.getenv("DATABASE_URL", "")
+    redis_url: str    = os.getenv("REDIS_URL", "")
 
     cloudinary_cloud_name: str = (
         os.getenv("CLOUDINARY_CLOUD_NAME")

main.py

@@ -79,28 +79,29 @@ async def lifespan(app: FastAPI):
     except Exception as e:
         logger.warning(f"Embedder failed to load: {e}")
 
-    # Eagerly load ASR models so warmup runs at startup, not on first request
-    try:
-        from src.asr.models import get_audio_model_en
-        get_audio_model_en()
-    except Exception as e:
-        logger.warning(f"English ASR model failed to load: {e}")
+    # # Eagerly load ASR models so warmup runs at startup, not on first request
+    # try:
+    #     from src.asr.models import get_audio_model_en
+    #     get_audio_model_en()
+    # except Exception as e:
+    #     logger.warning(f"English ASR model failed to load: {e}")
 
-    try:
-        from src.asr.models import get_audio_model_ar
-        get_audio_model_ar()
-    except Exception as e:
-        logger.warning(f"Arabic ASR model failed to load: {e}")
+    # try:
+    #     from src.asr.models import get_audio_model_ar
+    #     get_audio_model_ar()
+    # except Exception as e:
+    #     logger.warning(f"Arabic ASR model failed to load: {e}")
 
-    from src.rag.batch_workers import start_workers
-    start_workers()
+    # from src.rag.batch_workers import start_workers
+    # start_workers()
 
-    from src.asr.batch_workers import start_asr_workers
-    start_asr_workers()
+    # from src.asr.batch_workers import start_asr_workers
+    # start_asr_workers()
 
     yield
 
 
+
 from uvicorn.middleware.proxy_headers import ProxyHeadersMiddleware
 
 app = FastAPI(

rag/constants.py

@@ -16,6 +16,14 @@ DUCKDUCKGO_DOC_CONTENT_CHARS_MAX = 2500  # Max chars kept from combined DDG resu
 MEMORY_WINDOW_SIZE = 8                  # Number of previous conversation turns preserved in memory window
 TOP_K_CHUNKS = 4                         # Number of top relevant material chunks retrieved for context
 
+REFUSAL_PREFIXES = (
+    "I can't respond on a gibberish",
+    "I can't respond on a NSFW",
+    "I can't respond on a political",
+    "I can't respond on a religious",
+)
+
+
 RAG_PROMPT_TEMPLATE_BASE = """\
 <role>
 You are a helpful AI study assistant. You provide accurate, well-reasoned educational answers.{subject_line}

rag/routes.py

@@ -5,9 +5,10 @@ from fastapi import APIRouter, HTTPException, Depends
 from typing import Optional, Any
 
 from src.rag.rag import rag_answer, extract_chat_title
+from src.rag.constants import REFUSAL_PREFIXES
 from src.dependencies import get_current_user, get_current_user_id
 from src.store import (
-    get_material, get_chunks, get_summary, get_or_create_memory,
+    get_material, get_chunks, get_summary, get_or_create_memory, append_memory_message,
     # Session-based chat
     create_chat_session, list_chat_sessions, get_chat_session,
     rename_chat_session, delete_chat_session,
@@ -95,13 +96,7 @@ async def ask_tutor(
     elapsed = time.time() - start
 
     # Safety/refusal responses must not be saved to DB history either.
-    _REFUSAL_PREFIXES = (
-        "I can't respond on a gibberish",
-        "I can't respond on a NSFW",
-        "I can't respond on a political",
-        "I can't respond on a religious",
-    )
-    is_refusal = any(cleaned_answer.strip().startswith(p) for p in _REFUSAL_PREFIXES)
+    is_refusal = any(cleaned_answer.strip().startswith(p) for p in REFUSAL_PREFIXES)
 
     # Persist assistant response (only if not a refusal)
     if body.session_id and not is_refusal:
@@ -110,6 +105,11 @@ async def ask_tutor(
         except Exception:
             pass  # don't fail the response if saving fails
 
+    # Keep Redis memory cache in sync (append user + assistant messages)
+    if body.session_id and not is_refusal:
+        append_memory_message(memory_id, "user", body.query.strip())
+        append_memory_message(memory_id, "assistant", cleaned_answer)
+
     return TutorResponse(answer=cleaned_answer, source=source, time_taken=elapsed, memory_id=memory_id)
 
 

redis_client.py

@@ -0,0 +1,59 @@
+"""
+Redis client singleton with graceful fallback.
+
+Provides a single `get_redis()` function that returns a live Redis client
+when REDIS_URL is configured, or None when it is not — so every caller can
+do a simple `r = get_redis(); if r is None: <fallback>` without crashing.
+
+Connection is created once and reused for the lifetime of the process.
+"""
+
+import logging
+from typing import Optional
+
+import redis
+
+logger = logging.getLogger(__name__)
+
+_redis_client: Optional[redis.Redis] = None
+_redis_available: bool = False
+
+
+def get_redis() -> Optional[redis.Redis]:
+    """
+    Return a live Redis client, or None if Redis is not configured / reachable.
+
+    Thread-safe via module-level sentinel; first call initialises the client.
+    Subsequent calls return the same singleton.
+    """
+    global _redis_client, _redis_available
+
+    if _redis_client is not None:
+        return _redis_client if _redis_available else None
+
+    # Lazy import so config is already loaded before this module is imported
+    from src.config import settings
+
+    url = settings.redis_url
+    if not url:
+        logger.info("REDIS_URL not configured — Redis features will fall back to Supabase/in-memory.")
+        _redis_available = False
+        return None
+
+    try:
+        client = redis.Redis.from_url(
+            url,
+            decode_responses=True,  # always get str, not bytes
+            socket_connect_timeout=3,
+            socket_timeout=3,
+            retry_on_timeout=True,
+        )
+        client.ping()  # verify connectivity at startup
+        _redis_client = client
+        _redis_available = True
+        logger.info("Redis connected successfully.")
+        return _redis_client
+    except Exception as e:
+        logger.warning("Redis connection failed (%s) — falling back to Supabase/in-memory.", e)
+        _redis_available = False
+        return None

requirements.txt

@@ -33,6 +33,7 @@ PyJWT>=2.8.0
 passlib[bcrypt]>=1.7.4
 
 supabase
+redis>=5.0.0
 transformers
 sacremoses
 sentencepiece

store.py

@@ -1,11 +1,21 @@
 import os
 import time
+import json
 from httpx import RemoteProtocolError
 from typing import Optional
 import logging
 from datetime import datetime, timezone, date, timedelta
 from langchain.memory import ConversationBufferMemory, ConversationBufferWindowMemory
 from src.database import get_supabase
+from src.redis_client import get_redis
+
+# ── Redis Key Prefixes & TTLs ──────────────────────────────────────────────────
+MEMORY_KEY_PREFIX = "mem:"
+MEMORY_REDIS_TTL = 48 * 3600             # 48 hours — keeps active sessions warm
+MEMORY_MAX_MESSAGES = 20                 # Max message history retained in Redis cache (10 turns)
+
+DAILY_RATE_LIMIT_KEY_PREFIX = "rate:"
+DAILY_RATE_LIMIT_REDIS_TTL = 86400       # 24 hours — daily usage counter auto-expiration
 
 def _get_today_date_str() -> str:
     # Shift UTC time by 3 hours to match Egypt timezone (UTC+3), so daily limits reset at 12 AM Egypt time.
@@ -618,44 +628,127 @@ def get_session_messages(session_id: str) -> list[dict]:
     return result.data
 
 
-# ── Conversation Memory (in-memory, ephemeral) ─────────
+# ── Conversation Memory — Redis-backed, Python-dict fallback ─────────────────
 
 import uuid as _uuid
 
+# Fallback in-process dict for when Redis is unavailable
 _memories: dict[str, ConversationBufferMemory] = {}
 
 
-def get_or_create_memory(memory_id: Optional[str] = None, seed_messages: list[dict] | None = None):
-    """Get or create a ConversationBufferMemory, optionally seeding it from DB messages."""
-    if memory_id and memory_id in _memories:
-        return _memories[memory_id], memory_id
-    mid = memory_id or str(_uuid.uuid4())
+def _mem_redis_key(memory_id: str) -> str:
+    return f"{MEMORY_KEY_PREFIX}{memory_id}"
+
+
+def _load_memory_from_messages(messages: list[dict]) -> ConversationBufferWindowMemory:
+    """Build a fresh ConversationBufferWindowMemory from a flat message list."""
     mem = ConversationBufferWindowMemory(
         input_key="input", memory_key="chat_history", return_messages=True, k=5
     )
-    # Rebuild context from stored messages so it survives server restarts
-    if seed_messages:
-        for i in range(0, len(seed_messages) - 1, 2):
-            user_msg = seed_messages[i]
-            ai_msg = seed_messages[i + 1] if i + 1 < len(seed_messages) else None
-            if user_msg.get("role") == "user" and ai_msg and ai_msg.get("role") == "assistant":
-                mem.save_context(
-                    {"input": user_msg["content"]},
-                    {"output": ai_msg["content"]},
-                )
+    for i in range(0, len(messages) - 1, 2):
+        user_msg = messages[i]
+        ai_msg = messages[i + 1] if i + 1 < len(messages) else None
+        if user_msg.get("role") == "user" and ai_msg and ai_msg.get("role") == "assistant":
+            mem.save_context(
+                {"input": user_msg["content"]},
+                {"output": ai_msg["content"]},
+            )
+    return mem
+
+
+def get_or_create_memory(memory_id: Optional[str] = None, seed_messages: list[dict] | None = None):
+    """
+    Get or create a ConversationBufferWindowMemory.
+
+    Redis path (fast):
+        Checks `mem:{memory_id}` in Redis first.  If present, deserialises the
+        cached message list and builds memory from it — no Supabase query needed.
+        TTL is refreshed on each access so active conversations stay warm.
+
+    Fallback path (Supabase seed / in-process dict):
+        Falls back to `seed_messages` from Supabase (as before) and caches the
+        result in Redis so the next call skips Supabase entirely.
+    """
+    mid = memory_id or str(_uuid.uuid4())
+    r = get_redis()
+
+    # ── Redis path ────────────────────────────────────────────────────────────
+    if r is not None:
+        try:
+            rkey = _mem_redis_key(mid)
+            raw = r.get(rkey)
+            if raw:
+                cached_msgs: list[dict] = json.loads(raw)
+                mem = _load_memory_from_messages(cached_msgs)
+                r.expire(rkey, MEMORY_REDIS_TTL)   # refresh TTL on each use
+                return mem, mid
+        except Exception as e:
+            logger.warning("Redis get_or_create_memory read failed: %s", e)
+
+    # ── Seed from DB messages (Supabase / provided list) ─────────────────────
+    source_msgs: list[dict] = seed_messages or []
+    mem = _load_memory_from_messages(source_msgs)
+
+    # Cache in Redis so next request skips Supabase
+    if r is not None and source_msgs:
+        try:
+            rkey = _mem_redis_key(mid)
+            r.set(rkey, json.dumps(source_msgs), ex=MEMORY_REDIS_TTL)
+        except Exception as e:
+            logger.warning("Redis get_or_create_memory write failed: %s", e)
+
+    # Also keep the in-process fallback dict warm
     _memories[mid] = mem
     return mem, mid
 
 
+def append_memory_message(memory_id: str, role: str, content: str) -> None:
+    """
+    Append a single message to the Redis-cached message list for a session.
+
+    Called after each AI turn so Redis stays in sync without a full Supabase
+    round-trip.  Silently no-ops if Redis is unavailable.
+    """
+    r = get_redis()
+    if r is None:
+        return
+    try:
+        rkey = _mem_redis_key(memory_id)
+        raw = r.get(rkey)
+        msgs: list[dict] = json.loads(raw) if raw else []
+        msgs.append({"role": role, "content": content})
+        # Keep only the last N messages to cap memory usage
+        msgs = msgs[-MEMORY_MAX_MESSAGES:]
+        r.set(rkey, json.dumps(msgs), ex=MEMORY_REDIS_TTL)
+    except Exception as e:
+        logger.warning("append_memory_message Redis failed: %s", e)
+
+
 def check_daily_limit(user_id: str, email: Optional[str] = None, limit: int = 20) -> bool:
     """
     Checks if the user is under the daily limit. Returns True if allowed, False if exceeded.
     Does NOT increment the count.
+
+    Redis path: atomic GET on `rate:{user_id}:{date}` (<5 ms, no Supabase hit).
+    Fallback: existing Supabase profiles query.
     """
     if email and email in ADMIN_EMAILS:
         return True
 
     today = _get_today_date_str()
+
+    # ── Redis path ────────────────────────────────────────────────────────────
+    r = get_redis()
+    if r is not None:
+        try:
+            rkey = f"{DAILY_RATE_LIMIT_KEY_PREFIX}{user_id}:{today}"
+            val = r.get(rkey)
+            count = int(val) if val is not None else 0
+            return count < limit
+        except Exception as e:
+            logger.warning("Redis check_daily_limit failed: %s — falling back to Supabase", e)
+
+    # ── Supabase fallback ─────────────────────────────────────────────────────
     try:
         result = _robust_execute(
             _table_supabase("profiles")
@@ -672,9 +765,7 @@ def check_daily_limit(user_id: str, email: Optional[str] = None, limit: int = 20
         count = profile.get("daily_requests", 0) or 0
         if last_date != today:
             count = 0
-        if count >= limit:
-            return False
-        return True
+        return count < limit
     except Exception as e:
         logger.error(f"Rate limit check failed: {e}")
         return True
@@ -683,8 +774,25 @@ def check_daily_limit(user_id: str, email: Optional[str] = None, limit: int = 20
 def increment_daily_usage(user_id: str) -> None:
     """
     Increments the daily request count for the user.
+
+    Redis path: atomic INCR + EXPIRE on `rate:{user_id}:{date}` (microseconds).
+    Always also updates Supabase so the dashboard & DB stay in sync.
     """
     today = _get_today_date_str()
+
+    # ── Redis path — atomic INCR ──────────────────────────────────────────────
+    r = get_redis()
+    if r is not None:
+        try:
+            rkey = f"{DAILY_RATE_LIMIT_KEY_PREFIX}{user_id}:{today}"
+            pipe = r.pipeline()
+            pipe.incr(rkey)
+            pipe.expire(rkey, DAILY_RATE_LIMIT_REDIS_TTL)   # auto-expire at next calendar day
+            pipe.execute()
+        except Exception as e:
+            logger.warning("Redis increment_daily_usage failed: %s", e)
+
+    # ── Supabase — keep DB in sync for audit / dashboard ─────────────────────
     try:
         result = _robust_execute(
             _table_supabase("profiles")
@@ -724,8 +832,24 @@ def check_and_increment_daily_limit(user_id: str, email: Optional[str] = None, l
 def get_usage(user_id: str) -> dict:
     """
     Returns current usage for a user.
+
+    Redis path: read rate counter directly (<5 ms).
+    Fallback: Supabase profiles query.
     """
     today = _get_today_date_str()
+
+    # ── Redis path ────────────────────────────────────────────────────────────
+    r = get_redis()
+    if r is not None:
+        try:
+            rkey = f"{DAILY_RATE_LIMIT_KEY_PREFIX}{user_id}:{today}"
+            val = r.get(rkey)
+            used = int(val) if val is not None else 0
+            return {"used": used, "limit": 20, "remaining": max(0, 20 - used)}
+        except Exception as e:
+            logger.warning("Redis get_usage failed: %s — falling back to Supabase", e)
+
+    # ── Supabase fallback ─────────────────────────────────────────────────────
     try:
         result = _robust_execute(
             _table_supabase("profiles")