feat: leveraged Redis to store sontext in cache

Author: Sai Rishi S

app/api/router.py

@@ -12,6 +12,9 @@
 from app.tools.presentation_generator.tools.slides_generator import SlidesGenerator
 import uuid
 from fastapi import FastAPI
+from fastapi import Request
+import json
+from app.services.cache_service import CacheInterface
 
 logger = setup_logger(__name__)
 router = APIRouter()
@@ -21,6 +24,11 @@
 if not hasattr(app.state, "presentation_contexts"):
     app.state.presentation_contexts = {}
 
+
+# Dependency injection
+async def get_cache_service(request: Request) -> CacheInterface:
+    return request.app.state.cache_service
+
 @router.get("/")
 def read_root():
     return {"Hello": "World"}
@@ -29,20 +37,27 @@ def read_root():
 # 1. Generate outline with initial inputs
 # 2. Generate slides using stored outline and inputs
 @router.post("/generate-outline", response_model=Union[ToolResponse, ErrorResponse])
-async def generate_outline(data: ToolRequest, _ = Depends(key_check)):
+async def generate_outline(
+    data: ToolRequest, 
+    cache: CacheInterface = Depends(get_cache_service),
+    _ = Depends(key_check)
+):
     try:
-        # Execute outline generation and store context for slides
+        # Potential Bottleneck: execute tool can be a blocking operation
+        # Solution: Use Redis Queue or Celery for background tasks
+        # Execute outline generation and store context for slides generation
         request_data = data.tool_data
         requested_tool = load_tool_metadata(request_data.tool_id)
         request_inputs_dict = finalize_inputs(request_data.inputs, requested_tool['inputs'])
         result = execute_tool(request_data.tool_id, request_inputs_dict)
 
-        # Store in app state, to use as context for slides generation
+        # Store in app cache, to use as context for slides generation
         presentation_id = str(uuid.uuid4())
-        app.state.presentation_contexts[presentation_id] = {
-            "outline": result,
-            "inputs": request_inputs_dict
-        }
+        
+        await cache.set(
+            f"presentation:{presentation_id}",
+            json.dumps({"outline": result, "inputs": request_inputs_dict})
+        )
 
         return ToolResponse(data={
             "outline": result,
@@ -64,16 +79,17 @@ async def generate_outline(data: ToolRequest, _ = Depends(key_check)):
         )
 
 @router.post("/generate-slides/{presentation_id}", response_model=Union[ToolResponse, ErrorResponse])
-async def generate_slides(presentation_id: str, _ = Depends(key_check)):
+async def generate_slides(
+    presentation_id: str,
+    cache: CacheInterface = Depends(get_cache_service),
+    _ = Depends(key_check)
+):
     try:
-        # Retrieve stored context and generate slides
-        context = app.state.presentation_contexts.get(presentation_id)
-        if not context:
-            raise HTTPException(
-                status_code=404, 
-                detail="Presentation context not found"
-            )
+        context_str = await cache.get(f"presentation:{presentation_id}")
+        if not context_str:
+            raise HTTPException(status_code=404)
 
+        context = json.loads(context_str)
         slides = SlidesGenerator(
             outline=context["outline"],
             inputs=context["inputs"]

app/main.py

@@ -5,6 +5,7 @@
 from contextlib import asynccontextmanager
 from app.api.router import router
 from app.services.logger import setup_logger
+from app.services.cache_service import RedisService
 from app.api.error_utilities import ErrorResponse
 
 import os
@@ -18,6 +19,10 @@
 async def lifespan(app: FastAPI):
     logger.info(f"Initializing Application Startup")
     logger.info(f"Successfully Completed Application Startup")
+
+    app.state.cache_service = RedisService()
+
+    logger.info(f"Cache Service Initialized")
 
     yield
     logger.info("Application shutdown")

app/services/cache_service.py

@@ -0,0 +1,27 @@
+from redis.asyncio import Redis
+from abc import ABC, abstractmethod
+import os
+
+# Abstract interface (SOLID - Interface Segregation)
+class CacheInterface(ABC):
+    @abstractmethod
+    async def get(self, key: str): pass
+    
+    @abstractmethod
+    async def set(self, key: str, value: str, ttl: int = None): pass
+
+# Concrete implementation
+class RedisService(CacheInterface):
+    def __init__(self, redis_client: Redis = None):
+        self.client = redis_client or Redis(
+            host=os.getenv('REDIS_HOST', 'redis'),
+            port=int(os.getenv('REDIS_PORT', 6379)),
+            db=int(os.getenv('REDIS_DB', 0)),
+            decode_responses=True
+        )
+    
+    async def get(self, key: str):
+        return await self.client.get(key)
+    
+    async def set(self, key: str, value: str, ttl: int = None):
+        return await self.client.set(key, value, ex=ttl)

docker-compose.yml

@@ -0,0 +1,17 @@
+services:
+  app:
+    build: .
+    ports:
+      - "8000:8000"
+    volumes:
+      - .:/app  # Enables live code changes
+    env_file:
+      - app/.env  # Path to your .env file
+    depends_on:
+      - redis
+    command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload  # --reload for live changes
+
+  redis:
+    image: redis
+    ports:
+      - "6379:6379"

requirements.txt

@@ -37,4 +37,6 @@ psutil
 pydub
 ffmpeg-python
 speechrecognition
-google-cloud-speech
+google-cloud-speech
+redis[hiredis]>=5.0.0
+aioredis>=2.0.0