Epic 2.16: Presentation Generator with New Functionality (PoC)

app/api/router.py

@@ -9,16 +9,108 @@
 from app.services.logger import setup_logger
 from app.api.error_utilities import InputValidationError, ErrorResponse
 from app.tools.utils.tool_utilities import load_tool_metadata, execute_tool, finalize_inputs
-from fastapi.responses import FileResponse
-from starlette.background import BackgroundTask
+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()
+app = FastAPI()
+
+# Initialize presentation contexts in app state if not exists
+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"}
 
+# Handles two-step presentation generation:
+# 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, 
+    cache: CacheInterface = Depends(get_cache_service),
+    _ = Depends(key_check)
+):
+    try:
+        # 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 cache, to use as context for slides generation
+        presentation_id = str(uuid.uuid4())
+
+        await cache.set(
+            f"presentation:{presentation_id}",
+            json.dumps({"outline": result, "inputs": request_inputs_dict})
+        )
+
+        return ToolResponse(data={
+            "outline": result,
+            "presentation_id": presentation_id
+        })
+
+    except InputValidationError as e:
+        logger.error(f"InputValidationError: {e}")
+        return JSONResponse(
+            status_code=400,
+            content=jsonable_encoder(ErrorResponse(status=400, message=e.message))
+        )
+
+    except HTTPException as e:
+        logger.error(f"HTTPException: {e}")
+        return JSONResponse(
+            status_code=e.status_code,
+            content=jsonable_encoder(ErrorResponse(status=e.status_code, message=e.detail))
+        )
+
+@router.post("/generate-slides/{presentation_id}", response_model=Union[ToolResponse, ErrorResponse])
+async def generate_slides(
+    presentation_id: str,
+    cache: CacheInterface = Depends(get_cache_service),
+    _ = Depends(key_check)
+):
+    try:
+        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"]
+        ).compile()
+
+        return ToolResponse(data=slides)
+
+    except InputValidationError as e:
+        logger.error(f"InputValidationError: {e}")
+        return JSONResponse(
+            status_code=400,
+            content=jsonable_encoder(ErrorResponse(status=400, message=e.message))
+        )
+
+    except HTTPException as e:
+        logger.error(f"HTTPException: {e}")
+        return JSONResponse(
+            status_code=e.status_code,
+            content=jsonable_encoder(ErrorResponse(status=e.status_code, message=e.detail))
+        )
+
 @router.post("/submit-tool", response_model=Union[ToolResponse, ErrorResponse])
 async def submit_tool( data: ToolRequest, _ = Depends(key_check)):     
     try: 

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)

app/services/schemas.py

@@ -110,16 +110,12 @@ class ConnectWithThemArgs(BaseModel):
     student_description_file_type: str
     lang: str = Field(..., description="The language in which the subject is being taught.")
 
-class PresentationGeneratorInput(BaseModel):
+# Changed request schema to match the new functionality of the presentation generator
+class PresentationGeneratorArgs(BaseModel):
     grade_level: str
     n_slides: int
     topic: str
     objectives: str
-    additional_comments: str
-    objectives_file_url: str
-    objectives_file_type: str
-    additional_comments_file_url: str
-    additional_comments_file_type: str
     lang: Optional[str] = "en"
 
 class RubricGeneratorArgs(BaseModel):

app/tools/presentation_generator/core.py

@@ -1,6 +1,6 @@
 from app.utils.document_loaders import get_docs
-from app.tools.presentation_generator.tools import PresentationGenerator
-from app.services.schemas import PresentationGeneratorInput
+from app.tools.presentation_generator.tools.outline_generator import OutlineGenerator
+from app.services.schemas import PresentationGeneratorArgs
 from app.services.logger import setup_logger
 from app.api.error_utilities import LoaderError, ToolExecutorError
 
@@ -10,48 +10,20 @@ def executor(grade_level: str,
              n_slides: int,
              topic: str,
              objectives: str,
-             additional_comments: str,
-             objectives_file_url: str,
-             objectives_file_type: str,
-             additional_comments_file_url: str,
-             additional_comments_file_type: str,
              lang: str, 
              verbose=False):
 
     try:
-        if(objectives_file_type):
-            logger.info(f"Generating docs. from {objectives_file_type}")
-        if(additional_comments_file_type):
-            logger.info(f"Generating docs. from {additional_comments_file_type}")
 
-        docs = None
-
-        def fetch_docs(file_url, file_type):
-            return get_docs(file_url, file_type, True) if file_url and file_type else None
-
-        objectives_docs = fetch_docs(objectives_file_url, objectives_file_type)
-        additional_comments_docs = fetch_docs(additional_comments_file_url, additional_comments_file_type)
-
-        docs = (
-            objectives_docs + additional_comments_docs
-            if objectives_docs and additional_comments_docs
-            else objectives_docs or additional_comments_docs
-        )
-
-        presentation_generator_args = PresentationGeneratorInput(
+        presentation_generator_args = PresentationGeneratorArgs(
             grade_level=grade_level,
             n_slides=n_slides,
             topic=topic,
             objectives=objectives,
-            additional_comments=additional_comments,
-            objectives_file_url=objectives_file_url,
-            objectives_file_type=objectives_file_type,
-            additional_comments_file_url=additional_comments_file_url,
-            additional_comments_file_type=additional_comments_file_type,
             lang=lang
         )
 
-        output = PresentationGenerator(args=presentation_generator_args, verbose=verbose).generate_presentation(docs)
+        output = OutlineGenerator(args=presentation_generator_args, verbose=verbose).compile()
 
         logger.info(f"Presentation generated successfully")
 

app/tools/presentation_generator/metadata.json

@@ -1,4 +1,4 @@
-{
+{ 
     "inputs": [
         {
             "label": "Grade Level",
@@ -16,35 +16,10 @@
             "type": "text"
         },
         {
-            "label": "Standards/Objectives",
+            "label": "Objectives/Description",
             "name": "objectives",
             "type": "text"
         },
-        {
-            "label": "Additional Comments",
-            "name": "additional_comments",
-            "type": "text"
-        },
-        {
-            "label": "Standards/Objectives File URL",
-            "name": "objectives_file_url",
-            "type": "text"
-        },
-        {
-            "label": "Standards/Objectives File Type",
-            "name": "objectives_file_type",
-            "type": "text"
-        },
-        {
-            "label": "Additional Comments File URL",
-            "name": "additional_comments_file_url",
-            "type": "text"
-        },
-        {
-            "label": "Additional Comments File Type",
-            "name": "additional_comments_file_type",
-            "type": "text"
-        },
         {
             "label": "Language",
             "name": "lang",

app/tools/presentation_generator/tools/__init__.py

@@ -0,0 +1 @@
+

app/tools/presentation_generator/tools/outline_generator.py

@@ -0,0 +1,74 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional
+import os
+from app.services.logger import setup_logger
+from langchain_chroma import Chroma
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough, RunnableParallel
+from langchain_core.output_parsers import JsonOutputParser
+from langchain_google_genai import GoogleGenerativeAI
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+from langchain_core.documents import Document
+from app.services.schemas import PresentationGeneratorArgs
+from fastapi import HTTPException
+
+logger = setup_logger(__name__)
+
+class OutlineGenerator:
+    def __init__(self, args: PresentationGeneratorArgs, verbose=False):
+        # Initialize LLM and parser for outline generation
+        self.args = args
+        self.verbose = verbose
+        self.model = GoogleGenerativeAI(model="gemini-1.5-pro")
+        self.parser = JsonOutputParser(pydantic_object=OutlineSchema)
+
+    def compile(self) -> dict:
+        try:
+            # Create prompt for outline generation with learning objectives and structure
+            prompt = PromptTemplate(
+                template=(
+                    "Generate a coherent presentation outline for grade {grade_level} students.\n\n"
+                    "Topic: {topic}\n"
+                    "Number of slides needed: {n_slides}\n"
+                    "Learning objectives: {objectives}\n"
+                    "Language: {lang}\n\n"
+                    "Create an outline where:\n"
+                    "1. Each slide has a clear topic\n"
+                    "2. Include a brief description of the content\n"
+                    "3. Add transitions between slides for smooth flow\n"
+                    "4. Ensure content builds progressively\n"
+                    "5. Match the grade level's comprehension\n"
+                    "6. Generate exactly {n_slides} slides\n\n"
+                    "{format_instructions}"
+                ),
+                input_variables=["grade_level", "topic", "n_slides", "objectives", "lang"],
+                partial_variables={"format_instructions": self.parser.get_format_instructions()}
+            )
+
+            chain = prompt | self.model | self.parser
+
+            result = chain.invoke({
+                "grade_level": self.args.grade_level,
+                "topic": self.args.topic,
+                "n_slides": self.args.n_slides,
+                "objectives": self.args.objectives,
+                "lang": self.args.lang
+            })
+
+            if self.verbose:
+                logger.info(f"Generated outline successfully")
+
+            return dict(result)
+
+        except Exception as e:
+            logger.error(f"Failed to generate outline: {str(e)}")
+            raise HTTPException(status_code=500, detail=f"Failed to generate outline: {str(e)}")
+
+# Defines expected structure for each slide in the outline
+class OutlineSlide(BaseModel):
+    topic: str = Field(description="The main topic or title of the slide")
+    description: str = Field(description="Brief description of the slide content")
+    transition: str = Field(description="How this slide connects to the next one for smooth flow")
+
+class OutlineSchema(BaseModel):
+    slides: List[OutlineSlide] = Field(description="List of slides with their topics and descriptions")