Upload folder using huggingface_hub

.dockerignore

@@ -0,0 +1,16 @@
+.git
+.github
+.env
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.db
+temp.db
+.vscode
+.idea
+venv
+.venv
+node_modules
+.ipynb_checkpoints
+*.log

.gitattributes

@@ -1,35 +1 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+assets/bgm/*.mp3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+.env
+.env.example
+
+__pycache__
+Temp
+requirements.md

Dockerfile

@@ -0,0 +1,42 @@
+FROM python:3.11-slim
+
+# Install system dependencies
+# ffmpeg for audio/video processing
+# poppler-utils for pdf2image
+# default-libmysqlclient-dev or unixodbc-dev if needed for DB
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    poppler-utils \
+    libvips-dev \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory
+WORKDIR /code
+
+# Copy requirements file first for better caching
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create a non-root user (Hugging Face requirement for security)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+WORKDIR $HOME/app
+
+# Copy the rest of the application code
+COPY --chown=user . $HOME/app
+
+# Fix permissions for any local storage if needed
+RUN mkdir -p $HOME/app/assets && chmod 777 $HOME/app/assets
+
+# Use port 7860 as it's the default for Hugging Face Spaces
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,118 @@
 ---
-title: Creatorstudio Ai Backend
-emoji: 🏆
-colorFrom: purple
-colorTo: red
+title: CreatorStudio AI Backend
+emoji: 🚀
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# CreatorStudio AI Backend
+
+CreatorStudio AI is a powerful, enterprise-grade AI content generation and study platform. It leverages state-of-the-art Large Language Models (LLMs) and cloud infrastructure to transform documents and media into a wide array of educational and creative content.
+
+## 🚀 Features
+
+-   **🔐 Robust Authentication**: Secure JWT-based authentication system with password hashing and user-scoped data access.
+-   **📂 Source Management**: Integrated AWS S3 file management for seamless document uploads, listing, and storage.
+-   **🧠 Advanced RAG (Retrieval-Augmented Generation)**: Chat with your uploaded documents using Azure AI Search and OpenAI/Gemini, enabling high-precision context-aware interactions.
+-   **🎙️ Podcast Generation**: Automatically transform text and documents into professional podcast scripts and audio segments.
+-   **🎬 Video Generation**: Create engaging video summaries and slide-based videos from static content using MoviePy and FFmpeg.
+-   **📝 Interactive Study Tools**:
+    -   **Flashcards**: AI-generated flashcards tailored to your source material.
+    -   **Quizzes**: Customizable quizzes with multiple-choice questions, hints, and detailed explanations.
+    -   **Mind Maps**: Visualize complex relationships with auto-generated Mermaid.js mind maps.
+-   **📊 Smart Reports**: Generate structured, professional reports and summaries from various source materials.
+
+## 🛠️ Tech Stack
+
+-   **Framework**: FastAPI (Python 3.x)
+-   **Database**: SQLAlchemy ORM with support for relational databases (e.g., MSSQL/PostgreSQL).
+-   **AI Infrastructure**: 
+    -   **LLMs**: OpenAI GPT-4o, Google Gemini Pro.
+    -   **RAG**: Azure AI Search, Azure OpenAI Embeddings.
+-   **Cloud & Processing**: 
+    -   **Storage**: AWS S3, Azure Blob Storage.
+    -   **Media**: MoviePy, FFmpeg, Pydub for audio/video processing.
+    -   **Documents**: PyPDF2, pdf2image, Pillow for comprehensive document handling.
+
+## 📁 Project Structure
+
+```text
+CreatorStudio AI/
+├── api/                # FastAPI routers and endpoint logic
+│   ├── auth.py         # Authentication & User management
+│   ├── sources.py      # S3 Source file management
+│   ├── rag.py          # Azure RAG indexing and querying
+│   ├── podcast.py      # Podcast generation endpoints
+│   ├── flashcards.py   # Flashcard generation logic
+│   └── ...             # Quizzes, Mindmaps, Reports, Video Gen
+├── core/               # Core application configuration
+│   ├── config.py       # Pydantic settings & Environment management
+│   ├── database.py     # DB connection & Session management
+│   ├── prompts.py      # Centralized AI prompt templates
+│   └── security.py     # JWT & Password hashing utilities
+├── models/             # Data models
+│   ├── db_models.py    # SQLAlchemy database models (User, Source, RAG, etc.)
+│   └── schemas.py      # Pydantic request/response schemas for API
+├── services/           # Business logic & 3rd party integrations
+│   ├── s3_service.py   # AWS S3 integration
+│   ├── rag_service.py  # Azure AI Search & RAG logic
+│   ├── podcast_service.py # Podcast creation & script logic
+│   ├── video_generator_service.py # Video processing
+│   └── ...             # Specialized services for all features
+├── main.py             # Application entry point & Router inclusion
+└── requirements.txt    # Project dependencies
+```
+
+## ⚙️ Setup & Installation
+
+1.  **Clone the repository**
+2.  **Create a Virtual Environment**:
+    ```bash
+    python -m venv venv
+    source venv/bin/activate  # On Windows: venv\Scripts\activate
+    ```
+3.  **Install Dependencies**:
+    ```bash
+    pip install -r requirements.txt
+    ```
+4.  **Configure Environment Variables**:
+    Create a `.env` file in the root directory based on the following template:
+    ```env
+    # AWS Configuration
+    AWS_ACCESS_KEY_ID=your_aws_key
+    AWS_SECRET_ACCESS_KEY=your_aws_secret
+    AWS_S3_BUCKET=your_bucket_name
+
+    # Azure RAG & OpenAI
+    AZURE_SEARCH_ENDPOINT=your_endpoint
+    AZURE_SEARCH_KEY=your_search_key
+    AZURE_OPENAI_API_KEY=your_openai_key
+    AZURE_OPENAI_ENDPOINT=your_openai_endpoint
+
+    # LLM Keys
+    OPENAI_API_KEY=your_openai_key
+    GEMINI_API_KEY=your_gemini_key
+
+    # Database & Security
+    DATABASE_URL=your_db_connection_string
+    SECRET_KEY=your_jwt_secret_key
+    ```
+5.  **Run the Server**:
+    ```bash
+    python main.py
+    ```
+    The API will be available at `http://localhost:8000`. Access the interactive documentation at `http://localhost:8000/docs`.
+
+## 📖 API Documentation
+
+The backend provides a fully interactive Swagger UI at `/docs` for testing and exploration.
+
+-   **Auth**: `/api/auth/register`, `/api/auth/login`
+-   **Sources**: `/api/sources/upload`, `/api/sources/list`, `/api/sources/{id}`
+-   **RAG**: `/api/rag/index`, `/api/rag/query`
+-   **Content Generation**: `/api/podcast`, `/api/flashcards`, `/api/mindmaps`, `/api/quizzes`, `/api/reports`, `/api/video_generator`
+
+---
+© 2026 CreatorStudio AI Team. All rights reserved.

api/auth.py

@@ -0,0 +1,101 @@
+from typing import Optional
+from fastapi import APIRouter, Depends, HTTPException, status, Request, Form, Body
+from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
+from jose import JWTError, jwt
+from sqlalchemy.orm import Session
+from core.security import create_access_token, verify_password, get_password_hash
+from core.config import settings
+from core.database import get_db
+from models.schemas import UserCreate, Token, TokenData, UserResponse, UserLogin
+from models import db_models
+
+router = APIRouter(prefix="/api/auth", tags=["auth"])
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/api/auth/login")
+
+async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = Depends(get_db)):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        email: str = payload.get("sub")
+        if email is None:
+            raise credentials_exception
+        token_data = TokenData(email=email)
+    except JWTError:
+        raise credentials_exception
+    
+    user = db.query(db_models.User).filter(db_models.User.email == token_data.email).first()
+    if user is None:
+        raise credentials_exception
+    return user
+
+@router.post("/register", response_model=UserResponse)
+async def register(user_in: UserCreate, db: Session = Depends(get_db)):
+    db_user = db.query(db_models.User).filter(db_models.User.email == user_in.email).first()
+    if db_user:
+        raise HTTPException(
+            status_code=400,
+            detail="The user with this email already exists in the system.",
+        )
+    
+    hashed_password = get_password_hash(user_in.password)
+    new_user = db_models.User(
+        email=user_in.email,
+        hashed_password=hashed_password,
+        is_active=True
+    )
+    db.add(new_user)
+    db.commit()
+    db.refresh(new_user)
+    return new_user
+
+@router.post("/login", response_model=Token)
+async def login(
+    request: Request,
+    email: Optional[str] = Body(None),
+    password: Optional[str] = Body(None),
+    username: Optional[str] = Form(None),
+    password_form: Optional[str] = Form(None, alias="password"),
+    db: Session = Depends(get_db)):
+    """
+    Unified Login:
+    - For Web App: Send JSON {"email": "...", "password": "..."}
+    - For Swagger Popup: Enter Email in 'username' box.
+    """
+    final_email = email or username
+    final_password = password or password_form
+
+    if not final_email:
+        try:
+            if "application/json" in request.headers.get("content-type", ""):
+                body = await request.json()
+                final_email = body.get("email")
+                final_password = body.get("password")
+            else:
+                form_data = await request.form()
+                final_email = form_data.get("username") or form_data.get("email")
+                final_password = form_data.get("password")
+        except:
+            pass
+
+    if not final_email or not final_password:
+        raise HTTPException(
+            status_code=422, 
+            detail="Email and password are required. (In Swagger Popup, put email in 'username' box)"
+        )
+
+    user = db.query(db_models.User).filter(db_models.User.email == final_email).first()
+    if not user or not verify_password(final_password, user.hashed_password):
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect email or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    access_token = create_access_token(data={"sub": user.email})
+    return {"access_token": access_token, "token_type": "bearer"}
+    

api/chat.py

@@ -0,0 +1,141 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List
+import logging
+from openai import OpenAI
+
+from core.database import get_db
+from models import db_models, schemas
+from api.auth import get_current_user
+from services.rag_service import rag_service
+from core.config import settings
+
+router = APIRouter(prefix="/api/chat", tags=["AI Conversation"])
+logger = logging.getLogger(__name__)
+
+@router.get("/history", response_model=List[schemas.ChatMessageResponse])
+async def get_chat_history(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Retrieves the full AI conversation history for the current user.
+    """
+    messages = db.query(db_models.ChatMessage).filter(
+        db_models.ChatMessage.user_id == current_user.id
+    ).order_by(db_models.ChatMessage.created_at.asc()).all()
+    return messages
+
+@router.delete("/history")
+async def clear_chat_history(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Wipes the conversation history clean (Fresh Start).
+    """
+    db.query(db_models.ChatMessage).filter(
+        db_models.ChatMessage.user_id == current_user.id
+    ).delete()
+    db.commit()
+    return {"message": "All AI conversation history has been cleared."}
+
+@router.post("/query", response_model=schemas.ChatMessageResponse)
+async def ask_ai(
+    message_in: schemas.ChatMessageCreate,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Unified AI Endpoint: 
+    - Use this for general chat.
+    - Use this for PDF/Document specific questions (by providing rag_doc_id).
+    
+    It automatically manages conversation history and RAG context retrieval.
+    """
+    try:
+        openai_client = OpenAI(api_key=settings.OPENAI_API_KEY)
+        
+        history = db.query(db_models.ChatMessage).filter(
+            db_models.ChatMessage.user_id == current_user.id
+        ).order_by(db_models.ChatMessage.id.desc()).limit(10).all()
+        history.reverse() # Sort to chronological [oldest -> newest]
+
+        # 2. Save current user query to database
+        user_msg = db_models.ChatMessage(
+            user_id=current_user.id,
+            role="user",
+            content=message_in.query,
+            rag_doc_id=message_in.rag_doc_id
+        )
+        db.add(user_msg)
+        db.commit()
+
+        # 3. Context Retrieval (RAG)
+        context = ""
+        doc_filename = ""
+        if message_in.rag_doc_id:
+            rag_doc = db.query(db_models.RAGDocument).filter(
+                db_models.RAGDocument.id == message_in.rag_doc_id,
+                db_models.RAGDocument.user_id == current_user.id
+            ).first()
+            if rag_doc:
+                doc_filename = rag_doc.filename
+                results = rag_service.search_document(
+                    query=message_in.query,
+                    doc_id=rag_doc.azure_doc_id,
+                    user_id=current_user.id,
+                    top_k=5
+                )
+                context = "\n\n".join([r["content"] for r in results])
+
+        # 4. Build LLM Messages
+        llm_messages = [
+            {
+                "role": "system",
+                "content": (
+                    "You are a helpful AI assistant on the CreatorStudio platform. "
+                    "Use the provided conversation history and document context to answer the user. "
+                    "If the user refers to 'last message' or 'previous context', look at the history provided below."
+                )
+            }
+        ]
+        
+        # Add past messages (conversation history)
+        for msg in history:
+            llm_messages.append({"role": msg.role, "content": msg.content})
+
+        # Add RAG Knowledge if available
+        if context:
+            llm_messages.append({
+                "role": "system",
+                "content": f"REFERENTIAL KNOWLEDGE FROM DOCUMENT '{doc_filename}':\n\n{context}"
+            })
+
+        # Add current user query
+        llm_messages.append({"role": "user", "content": message_in.query})
+
+        # 5. Get AI Response
+        response = openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=llm_messages,
+            temperature=0.7
+        )
+        ai_response_text = response.choices[0].message.content
+
+        # 6. Save assistant response to database
+        assistant_msg = db_models.ChatMessage(
+            user_id=current_user.id,
+            role="assistant",
+            content=ai_response_text,
+            rag_doc_id=message_in.rag_doc_id
+        )
+        db.add(assistant_msg)
+        db.commit()
+        db.refresh(assistant_msg)
+
+        return assistant_msg
+
+    except Exception as e:
+        logger.error(f"Unified AI Query failed: {e}")
+        raise HTTPException(status_code=500, detail=f"AI Error: {str(e)}")

api/flashcards.py

@@ -0,0 +1,166 @@
+import logging
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List, Dict
+
+from api.auth import get_current_user
+from models import db_models
+from models.schemas import FlashcardGenerateRequest, FlashcardSetResponse, FlashcardResponse
+from core.database import get_db
+from services.flashcard_service import flashcard_service
+from core import constants
+
+router = APIRouter(prefix="/api/flashcards", tags=["flashcards"])
+logger = logging.getLogger(__name__)
+
+@router.get("/config")
+async def get_flashcard_config():
+    """Returns available difficulties, quantities, and languages for flashcards."""
+    return {
+        "difficulties": constants.DIFFICULTIES,
+        "quantities": constants.FLASHCARD_QUANTITIES,
+        "languages": constants.LANGUAGES
+    }
+
+@router.post("/generate", response_model=FlashcardSetResponse)
+async def generate_flashcards(
+    request: FlashcardGenerateRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Generates a set of flashcards and saves them to the database.
+    """
+    try:
+        source_id = None
+        if request.file_key:
+            # Verify file ownership
+            source = db.query(db_models.Source).filter(
+                db_models.Source.s3_key == request.file_key,
+                db_models.Source.user_id == current_user.id
+            ).first()
+            if not source:
+                raise HTTPException(status_code=403, detail="Not authorized to access this file")
+            source_id = source.id
+
+        # 1. Generate Flashcards from AI
+        cards_data = await flashcard_service.generate_flashcards(
+            file_key=request.file_key,
+            text_input=request.text_input,
+            difficulty=request.difficulty,
+            quantity=request.quantity,
+            topic=request.topic,
+            language=request.language
+        )
+
+        if not cards_data:
+            raise HTTPException(status_code=500, detail="Failed to generate flashcards")
+
+        # 2. Save Flashcard Set to DB
+        title = request.topic if request.topic else f"Flashcards {len(cards_data)}"
+        db_set = db_models.FlashcardSet(
+            title=title,
+            difficulty=request.difficulty,
+            user_id=current_user.id,
+            source_id=source_id
+        )
+        db.add(db_set)
+        db.commit()
+        db.refresh(db_set)
+
+        # 3. Save individual flashcards
+        for item in cards_data:
+            db_card = db_models.Flashcard(
+                flashcard_set_id=db_set.id,
+                question=item.get("question", ""),
+                answer=item.get("answer", "")
+            )
+            db.add(db_card)
+        
+        db.commit()
+        db.refresh(db_set)
+
+        return db_set
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Flashcard generation endpoint failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/sets", response_model=List[FlashcardSetResponse])
+async def list_flashcard_sets(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Lists all flashcard sets for the current user.
+    """
+    try:
+        sets = db.query(db_models.FlashcardSet).filter(
+            db_models.FlashcardSet.user_id == current_user.id
+        ).order_by(db_models.FlashcardSet.created_at.desc()).all()
+        return sets
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/set/{set_id}", response_model=FlashcardSetResponse)
+async def get_flashcard_set(
+    set_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Retrieves a specific flashcard set.
+    """
+    db_set = db.query(db_models.FlashcardSet).filter(
+        db_models.FlashcardSet.id == set_id,
+        db_models.FlashcardSet.user_id == current_user.id
+    ).first()
+    
+    if not db_set:
+        raise HTTPException(status_code=404, detail="Flashcard set not found")
+    
+    return db_set
+
+@router.post("/explain")
+async def explain_flashcard(
+    question: str,
+    file_key: str = None,
+    language: str = "English",
+    current_user: db_models.User = Depends(get_current_user)
+):
+    """
+    Provides a detailed explanation for a specific question.
+    """
+    try:
+        explanation = await flashcard_service.generate_explanation(
+            question=question,
+            file_key=file_key,
+            language=language
+        )
+        return {"explanation": explanation}
+    except Exception as e:
+        logger.error(f"Explanation failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/set/{set_id}")
+async def delete_flashcard_set(
+    set_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Deletes a specific flashcard set and all its cards.
+    """
+    db_set = db.query(db_models.FlashcardSet).filter(
+        db_models.FlashcardSet.id == set_id,
+        db_models.FlashcardSet.user_id == current_user.id
+    ).first()
+    
+    if not db_set:
+        raise HTTPException(status_code=404, detail="Flashcard set not found")
+    
+    db.delete(db_set)
+    db.commit()
+    return {"message": "Flashcard set and all associated cards deleted successfully"}

api/mindmaps.py

@@ -0,0 +1,111 @@
+import logging
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List
+
+from api.auth import get_current_user
+from models import db_models
+from models.schemas import MindMapGenerateRequest, MindMapResponse
+from core.database import get_db
+from services.mindmap_service import mindmap_service
+
+router = APIRouter(prefix="/api/mindmaps", tags=["mindmaps"])
+logger = logging.getLogger(__name__)
+
+@router.post("/generate", response_model=MindMapResponse)
+async def generate_mindmap(
+    request: MindMapGenerateRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Generates a mind map in Mermaid format and saves it to the database.
+    """
+    try:
+        source_id = None
+        if request.file_key:
+            # Verify file ownership
+            source = db.query(db_models.Source).filter(
+                db_models.Source.s3_key == request.file_key,
+                db_models.Source.user_id == current_user.id
+            ).first()
+            if not source:
+                raise HTTPException(status_code=403, detail="Not authorized to access this file")
+            source_id = source.id
+
+        # 1. Generate Mind Map from AI
+        mermaid_code = await mindmap_service.generate_mindmap(
+            file_key=request.file_key,
+            text_input=request.text_input
+        )
+
+        if not mermaid_code:
+            raise HTTPException(status_code=500, detail="Failed to generate mind map")
+
+        # 2. Save to DB
+        title = request.title if request.title else (request.file_key.split('/')[-1] if request.file_key else "Untitled Mind Map")
+        db_mindmap = db_models.MindMap(
+            title=title,
+            mermaid_code=mermaid_code,
+            user_id=current_user.id,
+            source_id=source_id
+        )
+        db.add(db_mindmap)
+        db.commit()
+        db.refresh(db_mindmap)
+
+        return MindMapResponse(
+            title=db_mindmap.title,
+            mermaid_code=db_mindmap.mermaid_code,
+            message="Mind map generated successfully"
+        )
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Mind map generation endpoint failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/list", response_model=List[MindMapResponse])
+async def list_mindmaps(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Lists all mind maps for the current user.
+    """
+    try:
+        mindmaps = db.query(db_models.MindMap).filter(
+            db_models.MindMap.user_id == current_user.id
+        ).order_by(db_models.MindMap.created_at.desc()).all()
+        
+        return [
+            MindMapResponse(
+                title=m.title,
+                mermaid_code=m.mermaid_code,
+                message="Retrieved successfully"
+            ) for m in mindmaps
+        ]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/{mindmap_id}")
+async def delete_mindmap(
+    mindmap_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Deletes a specific mind map.
+    """
+    mindmap = db.query(db_models.MindMap).filter(
+        db_models.MindMap.id == mindmap_id,
+        db_models.MindMap.user_id == current_user.id
+    ).first()
+    
+    if not mindmap:
+        raise HTTPException(status_code=404, detail="Mind map not found")
+    
+    db.delete(mindmap)
+    db.commit()
+    return {"message": "Mind map deleted successfully"}

api/podcast.py

@@ -0,0 +1,207 @@
+import os
+import logging
+from datetime import datetime
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import Dict, List
+
+from api.auth import get_current_user
+from models.schemas import PodcastAnalyzeRequest, PodcastGenerateRequest
+from models import db_models
+from core.database import get_db
+from services.podcast_service import podcast_service
+from services.s3_service import s3_service
+from core import constants
+
+router = APIRouter(prefix="/api/podcast", tags=["podcast"])
+logger = logging.getLogger(__name__)
+
+@router.get("/config")
+async def get_podcast_config():
+    """Returns available voices, BGM, and formats for podcast generation."""
+    return {
+        "voices": constants.PODCAST_VOICES,
+        "bgm": constants.PODCAST_BGM,
+        "formats": constants.PODCAST_FORMATS
+    }
+
+@router.post("/analyze")
+async def analyze_source(
+    request: PodcastAnalyzeRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)):
+    """
+    Analyzes a source file from S3 and proposes podcast structures.
+    """
+    try:
+        # Verify file ownership via DB
+        source = db.query(db_models.Source).filter(
+            db_models.Source.s3_key == request.file_key,
+            db_models.Source.user_id == current_user.id
+        ).first()
+        
+        if not source:
+             raise HTTPException(status_code=403, detail="Not authorized to access this file or file does not exist")
+
+        analysis = await podcast_service.analyze_pdf(
+            file_key=request.file_key,
+            duration_minutes=request.duration_minutes
+        )
+        return {"analysis": analysis}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Analysis failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/generate")
+async def generate_podcast(
+    request: PodcastGenerateRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Generates a podcast script and then the audio.
+    Saves metadata to DB and returns the generated info.
+    """
+    try:
+        # 1. Verify file ownership if provided
+        if request.file_key:
+            source = db.query(db_models.Source).filter(
+                db_models.Source.s3_key == request.file_key,
+                db_models.Source.user_id == current_user.id
+            ).first()
+            if not source:
+                raise HTTPException(status_code=403, detail="Not authorized to access this file")
+
+        # 2. Generate Script
+        script = await podcast_service.generate_script(
+            user_prompt=request.user_prompt,
+            model=request.model,
+            duration_minutes=request.duration_minutes,
+            podcast_format=request.podcast_format,
+            pdf_suggestions=request.pdf_suggestions,
+            file_key=request.file_key
+        )
+
+        if not script:
+             raise HTTPException(status_code=500, detail="Failed to generate script")
+
+        # 3. Generate Audio
+        audio_path = await podcast_service.generate_full_audio(
+            script=script,
+            tts_model=request.tts_model,
+            spk1_voice=request.spk1_voice,
+            spk2_voice=request.spk2_voice,
+            temperature=request.temperature,
+            bgm_choice=request.bgm_choice
+        )
+
+        if not audio_path:
+             raise HTTPException(status_code=500, detail="Failed to generate audio")
+
+        # 4. Upload to S3
+        filename = os.path.basename(audio_path)
+        with open(audio_path, "rb") as f:
+            content = f.read()
+        
+        s3_key = f"users/{current_user.id}/outputs/podcasts/{filename}"
+        
+        import boto3
+        from core.config import settings
+        s3_client = boto3.client('s3', 
+                                aws_access_key_id=settings.AWS_ACCESS_KEY_ID, 
+                                aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+                                region_name=settings.AWS_REGION)
+        s3_client.put_object(Bucket=settings.AWS_S3_BUCKET, Key=s3_key, Body=content)
+        
+        public_url = s3_service.get_public_url(s3_key)
+        private_url = s3_service.get_presigned_url(s3_key)
+
+        # 5. Save to DB
+        db_podcast = db_models.Podcast(
+            title=f"Podcast {datetime.utcnow().strftime('%Y-%m-%d %H:%M')}",
+            s3_key=s3_key,
+            s3_url=public_url,
+            script=script,
+            user_id=current_user.id
+        )
+        db.add(db_podcast)
+        db.commit()
+        db.refresh(db_podcast)
+
+        # Clean up local file
+        os.remove(audio_path)
+
+        return {
+            "id": db_podcast.id,
+            "message": "Podcast generated successfully",
+            "script": script,
+            "public_url": public_url,
+            "private_url": private_url
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Podcast generation failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/list")
+async def list_podcasts(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Lists all podcasts for the current user.
+    """
+    try:
+        podcasts = db.query(db_models.Podcast).filter(
+            db_models.Podcast.user_id == current_user.id
+        ).order_by(db_models.Podcast.created_at.desc()).all()
+        
+        return [
+            {
+                "id": p.id,
+                "title": p.title,
+                "s3_key": p.s3_key,
+                "public_url": p.s3_url,
+                "private_url": s3_service.get_presigned_url(p.s3_key),
+                "script_preview": (p.script[:200] + "...") if p.script else "",
+                "created_at": p.created_at
+            }
+            for p in podcasts
+        ]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/{podcast_id}")
+async def delete_podcast(
+    podcast_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Deletes a specific podcast from database and S3.
+    """
+    podcast = db.query(db_models.Podcast).filter(
+        db_models.Podcast.id == podcast_id,
+        db_models.Podcast.user_id == current_user.id
+    ).first()
+    
+    if not podcast:
+        raise HTTPException(status_code=404, detail="Podcast not found")
+    
+    try:
+        # 1. Delete from S3
+        await s3_service.delete_file(podcast.s3_key)
+        
+        # 2. Delete from DB
+        db.delete(podcast)
+        db.commit()
+        
+        return {"message": "Podcast and associated audio file deleted successfully"}
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Failed to delete podcast: {e}")
+        raise HTTPException(status_code=500, detail=f"Deletion failed: {str(e)}")

api/quizzes.py

@@ -0,0 +1,146 @@
+import logging
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List
+
+from api.auth import get_current_user
+from models import db_models
+from models.schemas import QuizGenerateRequest, QuizSetResponse
+from core.database import get_db
+from services.quiz_service import quiz_service
+from core import constants
+
+router = APIRouter(prefix="/api/quizzes", tags=["quizzes"])
+logger = logging.getLogger(__name__)
+
+@router.get("/config")
+async def get_quiz_config():
+    """Returns available difficulties, count options, and languages for quizzes."""
+    return {
+        "difficulties": constants.DIFFICULTIES,
+        "counts": constants.QUIZ_COUNTS,
+        "languages": constants.LANGUAGES
+    }
+
+@router.post("/generate", response_model=QuizSetResponse)
+async def generate_quiz(
+    request: QuizGenerateRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Generates a set of quiz questions and saves them to the database.
+    """
+    try:
+        source_id = None
+        if request.file_key:
+            source = db.query(db_models.Source).filter(
+                db_models.Source.s3_key == request.file_key,
+                db_models.Source.user_id == current_user.id
+            ).first()
+            if not source:
+                raise HTTPException(status_code=403, detail="Not authorized to access this file")
+            source_id = source.id
+
+        # 1. Generate Quiz from AI
+        quizzes_data = await quiz_service.generate_quiz(
+            file_key=request.file_key,
+            text_input=request.text_input,
+            difficulty=request.difficulty,
+            topic=request.topic,
+            language=request.language,
+            count_mode=request.count
+        )
+
+        if not quizzes_data:
+            raise HTTPException(status_code=500, detail="Failed to generate quiz")
+
+        # 2. Save Quiz Set
+        title = request.topic if request.topic else f"Quiz {len(quizzes_data)}"
+        db_set = db_models.QuizSet(
+            title=title,
+            difficulty=request.difficulty,
+            user_id=current_user.id,
+            source_id=source_id
+        )
+        db.add(db_set)
+        db.commit()
+        db.refresh(db_set)
+
+        # 3. Save Questions
+        for item in quizzes_data:
+            db_question = db_models.QuizQuestion(
+                quiz_set_id=db_set.id,
+                question=item.get("question", ""),
+                hint=item.get("hint", ""),
+                choices=item.get("choices", {}),
+                answer=item.get("answer", "1"),
+                explanation=item.get("explanation", "")
+            )
+            db.add(db_question)
+        
+        db.commit()
+        db.refresh(db_set)
+
+        return db_set
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Quiz generation endpoint failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/sets", response_model=List[QuizSetResponse])
+async def list_quiz_sets(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Lists all quiz sets for the current user.
+    """
+    try:
+        sets = db.query(db_models.QuizSet).filter(
+            db_models.QuizSet.user_id == current_user.id
+        ).order_by(db_models.QuizSet.created_at.desc()).all()
+        return sets
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/set/{set_id}", response_model=QuizSetResponse)
+async def get_quiz_set(
+    set_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Retrieves a specific quiz set.
+    """
+    db_set = db.query(db_models.QuizSet).filter(
+        db_models.QuizSet.id == set_id,
+        db_models.QuizSet.user_id == current_user.id
+    ).first()
+    
+    if not db_set:
+        raise HTTPException(status_code=404, detail="Quiz set not found")
+    
+    return db_set
+
+@router.delete("/set/{set_id}")
+async def delete_quiz_set(
+    set_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)):
+    """
+    Deletes a specific quiz set and all its questions.
+    """
+    db_set = db.query(db_models.QuizSet).filter(
+        db_models.QuizSet.id == set_id,
+        db_models.QuizSet.user_id == current_user.id
+    ).first()
+    
+    if not db_set:
+        raise HTTPException(status_code=404, detail="Quiz set not found")
+    
+    db.delete(db_set)
+    db.commit()
+    return {"message": "Quiz set and all associated questions deleted successfully"}

api/rag.py

@@ -0,0 +1,280 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from pydantic import BaseModel
+from typing import List, Optional
+import logging
+import PyPDF2
+import io
+import uuid
+
+from core.database import get_db
+from models import db_models
+from services.rag_service import rag_service
+from services.s3_service import s3_service
+from api.auth import get_current_user
+from core.config import settings
+from openai import OpenAI
+
+router = APIRouter(prefix="/api/rag", tags=["RAG Document Management"])
+logger = logging.getLogger(__name__)
+
+# Request/Response Models
+class RAGIndexRequest(BaseModel):
+    file_key: str  # S3 key of source file to index
+
+class RAGIndexResponse(BaseModel):
+    id: int
+    filename: str
+    azure_doc_id: str
+    chunk_count: int
+    message: str
+
+class RAGDocumentResponse(BaseModel):
+    id: int
+    filename: str
+    azure_doc_id: str
+    chunk_count: int
+    source_id: Optional[int]
+    created_at: str
+
+    class Config:
+        from_attributes = True
+
+def extract_text_from_pdf(file_content: bytes) -> str:
+    """Extract text from PDF file."""
+    try:
+        pdf_reader = PyPDF2.PdfReader(io.BytesIO(file_content))
+        text = ""
+        for page in pdf_reader.pages:
+            text += page.extract_text() + "\n"
+        return text.strip()
+    except Exception as e:
+        logger.error(f"Error extracting PDF text: {e}")
+        raise HTTPException(status_code=400, detail=f"Failed to extract text: {str(e)}")
+
+def chunk_text(text: str, chunk_size: int = 1000, overlap: int = 200) -> List[str]:
+    """Split text into overlapping chunks."""
+    chunks = []
+    start = 0
+    while start < len(text):
+        end = start + chunk_size
+        chunks.append(text[start:end])
+        start += (chunk_size - overlap)
+    return chunks
+
+@router.post("/index", response_model=RAGIndexResponse)
+async def index_document(
+    request: RAGIndexRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)):
+    """
+    Index a document for AI search (one-time operation).
+    Downloads from S3, extracts text, generates embeddings, stores in Azure Search.
+    """
+    try:
+        # 1. Verify file ownership
+        source = db.query(db_models.Source).filter(
+            db_models.Source.s3_key == request.file_key,
+            db_models.Source.user_id == current_user.id
+        ).first()
+        
+        if not source:
+            raise HTTPException(status_code=404, detail="File not found")
+        
+        # 2. Check if already indexed
+        existing = db.query(db_models.RAGDocument).filter(
+            db_models.RAGDocument.source_id == source.id,
+            db_models.RAGDocument.user_id == current_user.id
+        ).first()
+        
+        if existing:
+            return RAGIndexResponse(
+                id=existing.id,
+                filename=existing.filename,
+                azure_doc_id=existing.azure_doc_id,
+                chunk_count=existing.chunk_count,
+                message="Document already indexed"
+            )
+        
+        # 3. Download from S3
+        logger.info(f"Downloading {request.file_key}...")
+        
+        # Create temp local path
+        import tempfile
+        import os
+        with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(source.filename)[1]) as tmp:
+            temp_file = tmp.name
+            
+        s3_service.s3_client.download_file(
+            settings.AWS_S3_BUCKET,
+            request.file_key,
+            temp_file
+        )
+        
+        # 4. Extract text
+        try:
+            with open(temp_file, "rb") as f:
+                file_content = f.read()
+            
+            if source.filename.lower().endswith('.pdf'):
+                text = extract_text_from_pdf(file_content)
+            elif source.filename.lower().endswith('.txt'):
+                text = file_content.decode('utf-8')
+            else:
+                raise HTTPException(status_code=400, detail="Only PDF and TXT supported")
+            
+            if len(text) < 10:
+                raise HTTPException(status_code=400, detail="No readable text content found in file")
+            
+            # 5. Chunk text
+            chunks = chunk_text(text)
+            logger.info(f"Created {len(chunks)} chunks")
+            
+            # 6. Generate doc ID and index in Azure Search
+            doc_id = str(uuid.uuid4())
+            chunk_count = rag_service.index_document(
+                chunks=chunks,
+                filename=source.filename,
+                user_id=current_user.id,
+                doc_id=doc_id
+            )
+            
+            # 7. Save to database
+            rag_doc = db_models.RAGDocument(
+                filename=source.filename,
+                azure_doc_id=doc_id,
+                chunk_count=chunk_count,
+                user_id=current_user.id,
+                source_id=source.id
+            )
+            db.add(rag_doc)
+            db.commit()
+            db.refresh(rag_doc)
+            
+            logger.info(f"Successfully indexed {source.filename}")
+            
+            return RAGIndexResponse(
+                id=rag_doc.id,
+                filename=rag_doc.filename,
+                azure_doc_id=rag_doc.azure_doc_id,
+                chunk_count=rag_doc.chunk_count,
+                message="Document indexed successfully for AI conversation"
+            )
+        finally:
+            if os.path.exists(temp_file):
+                os.remove(temp_file)
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error indexing document: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Indexing failed: {str(e)}")
+
+@router.get("/documents", response_model=List[RAGDocumentResponse])
+async def list_indexed_documents(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """List all documents that have been processed and are ready for chatting."""
+    documents = db.query(db_models.RAGDocument).filter(
+        db_models.RAGDocument.user_id == current_user.id
+    ).order_by(db_models.RAGDocument.created_at.desc()).all()
+    
+    return [
+        RAGDocumentResponse(
+            id=doc.id,
+            filename=doc.filename,
+            azure_doc_id=doc.azure_doc_id,
+            chunk_count=doc.chunk_count,
+            source_id=doc.source_id,
+            created_at=doc.created_at.isoformat()
+        )
+        for doc in documents
+    ]
+
+@router.delete("/documents/{doc_id}")
+async def delete_indexed_document(
+    doc_id: str,  # Azure doc ID
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """Remove a document from the AI search index."""
+    # Find document
+    rag_doc = db.query(db_models.RAGDocument).filter(
+        db_models.RAGDocument.azure_doc_id == doc_id,
+        db_models.RAGDocument.user_id == current_user.id
+    ).first()
+    
+    if not rag_doc:
+        raise HTTPException(status_code=404, detail="Document index entry not found")
+    
+    try:
+        # Delete from Azure Search
+        rag_service.delete_document(doc_id)
+        
+        # Delete from database
+        db.delete(rag_doc)
+        db.commit()
+        
+        return {"message": "AI index for document deleted successfully"}
+        
+    except Exception as e:
+        logger.error(f"Error deleting document index: {e}")
+        raise HTTPException(status_code=500, detail=f"Deletion failed: {str(e)}")
+
+class RAGSummaryRequest(BaseModel):
+    rag_doc_id: int
+
+@router.post("/summary")
+async def generate_document_summary(
+    request: RAGSummaryRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Generate an on-the-fly summary for an indexed document.
+    No data is stored in the database.
+    """
+    try:
+        # 1. Verify existence and ownership
+        rag_doc = db.query(db_models.RAGDocument).filter(
+            db_models.RAGDocument.id == request.rag_doc_id,
+            db_models.RAGDocument.user_id == current_user.id
+        ).first()
+
+        if not rag_doc:
+            raise HTTPException(status_code=404, detail="Document not found")
+
+        # 2. Fetch top chunks to build a summary
+        # We search with a generic prompt to get a representative spread of content
+        results = rag_service.search_document(
+            query="Give me a general overview and executive summary of this document.",
+            doc_id=rag_doc.azure_doc_id,
+            user_id=current_user.id,
+            top_k=8 # Fetch more context for a better summary
+        )
+
+        if not results:
+            return {"summary": "No content found to summarize."}
+
+        context = "\n\n".join([r["content"] for r in results])
+
+        # 3. Generate summary using OpenAI
+        openai_client = OpenAI(api_key=settings.OPENAI_API_KEY)
+        response = openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {
+                    "role": "system", 
+                    "content": "You are a professional document analyst. Provide a concise, high-level summary (3-5 sentences) of the document based on the provided context."
+                },
+                {"role": "user", "content": f"Context from '{rag_doc.filename}':\n\n{context}"}
+            ],
+            temperature=0.5
+        )
+
+        return {"summary": response.choices[0].message.content}
+
+    except Exception as e:
+        logger.error(f"Summary generation failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Failed to generate summary: {str(e)}")

api/reports.py

@@ -0,0 +1,152 @@
+import logging
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List, Optional
+
+from api.auth import get_current_user
+from models import db_models
+from models.schemas import ReportGenerateRequest, ReportResponse, ReportFormatSuggestionResponse
+from core.database import get_db
+from services.report_service import report_service
+from core import constants
+
+router = APIRouter(prefix="/api/reports", tags=["reports"])
+logger = logging.getLogger(__name__)
+
+@router.get("/config")
+async def get_report_config():
+    """Returns available formats and languages for report generation."""
+    return {
+        "formats": constants.REPORT_FORMAT_OPTIONS,
+        "languages": constants.LANGUAGES
+    }
+
+@router.post("/suggest-formats", response_model=ReportFormatSuggestionResponse)
+async def suggest_formats(
+    file_key: Optional[str] = None,
+    text_input: Optional[str] = None,
+    language: str = "Japanese",
+    current_user: db_models.User = Depends(get_current_user)
+):
+    """
+    Get 4 AI-suggested report formats based on content.
+    """
+    suggestions = await report_service.generate_format_suggestions(
+        file_key=file_key,
+        text_input=text_input,
+        language=language
+    )
+    return {"suggestions": suggestions}
+
+@router.post("/generate", response_model=ReportResponse)
+async def generate_report(
+    request: ReportGenerateRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Generates a full report and saves it to the database.
+    """
+    try:
+        source_id = None
+        if request.file_key:
+            source = db.query(db_models.Source).filter(
+                db_models.Source.s3_key == request.file_key,
+                db_models.Source.user_id == current_user.id
+            ).first()
+            if not source:
+                raise HTTPException(status_code=403, detail="Not authorized to access this file")
+            source_id = source.id
+
+        # 1. Generate Report from AI
+        content = await report_service.generate_report(
+            file_key=request.file_key,
+            text_input=request.text_input,
+            format_key=request.format_key,
+            custom_prompt=request.custom_prompt,
+            language=request.language
+        )
+
+        if not content:
+            raise HTTPException(status_code=500, detail="Failed to generate report")
+
+        # 2. Extract title (usually the first line)
+        title = content.split('\n')[0].replace('#', '').strip()
+        if not title or len(title) < 3:
+            title = f"Report {request.format_key}"
+
+        # 3. Save to DB
+        db_report = db_models.Report(
+            title=title,
+            content=content,
+            format_key=request.format_key,
+            user_id=current_user.id,
+            source_id=source_id
+        )
+        db.add(db_report)
+        db.commit()
+        db.refresh(db_report)
+
+        return db_report
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Report generation endpoint failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/list", response_model=List[ReportResponse])
+async def list_reports(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Lists all reports for the current user.
+    """
+    try:
+        reports = db.query(db_models.Report).filter(
+            db_models.Report.user_id == current_user.id
+        ).order_by(db_models.Report.created_at.desc()).all()
+        return reports
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/{report_id}", response_model=ReportResponse)
+async def get_report(
+    report_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Retrieves a specific report.
+    """
+    report = db.query(db_models.Report).filter(
+        db_models.Report.id == report_id,
+        db_models.Report.user_id == current_user.id
+    ).first()
+    
+    if not report:
+        raise HTTPException(status_code=404, detail="Report not found")
+    
+    return report
+
+@router.delete("/{report_id}")
+async def delete_report(
+    report_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Deletes a specific report.
+    """
+    report = db.query(db_models.Report).filter(
+        db_models.Report.id == report_id,
+        db_models.Report.user_id == current_user.id
+    ).first()
+    
+    if not report:
+        raise HTTPException(status_code=404, detail="Report not found")
+    
+    db.delete(report)
+    db.commit()
+    return {"message": "Report deleted successfully"}

api/sources.py

@@ -0,0 +1,144 @@
+from fastapi import APIRouter, Depends, UploadFile, File, HTTPException
+from typing import List
+from sqlalchemy.orm import Session
+from services.s3_service import s3_service
+from api.auth import get_current_user
+from core.database import get_db
+from models import db_models
+from models.schemas import SourceFileResponse
+from services.rag_service import rag_service
+
+router = APIRouter(prefix="/api/sources", tags=["sources"])
+
+@router.post("/upload", response_model=dict)
+async def upload_source(
+    file: UploadFile = File(...),
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    try:
+        content = await file.read()
+        file_info = await s3_service.upload_file(
+            file_content=content,
+            filename=file.filename,
+            user_id=str(current_user.id)
+        )
+        
+        # Save metadata to database
+        db_source = db_models.Source(
+            filename=file.filename,
+            s3_key=file_info["key"],
+            s3_url=file_info["public_url"], # Store public URL in DB
+            size=len(content),
+            user_id=current_user.id
+        )
+        db.add(db_source)
+        db.commit()
+        db.refresh(db_source)
+
+        return {
+            "id": db_source.id,
+            "filename": file.filename, 
+            "key": file_info["key"], 
+            "public_url": file_info["public_url"],
+            "private_url": file_info["private_url"],
+            "message": "Upload successful"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/list", response_model=List[SourceFileResponse])
+async def list_sources(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    try:
+        # Join Source with RAGDocument to get indexing info if it exists
+        results = db.query(
+            db_models.Source,
+            db_models.RAGDocument.id.label("rag_id"),
+            db_models.RAGDocument.azure_doc_id
+        ).outerjoin(
+            db_models.RAGDocument, 
+            db_models.Source.id == db_models.RAGDocument.source_id
+        ).filter(
+            db_models.Source.user_id == current_user.id
+        ).all()
+        
+        response_sources = []
+        for source, rag_id, azure_doc_id in results:
+            response_sources.append({
+                "id": source.id,
+                "filename": source.filename,
+                "s3_key": source.s3_key,
+                "public_url": source.s3_url,
+                "private_url": s3_service.get_presigned_url(source.s3_key),
+                "size": source.size,
+                "created_at": source.created_at,
+                "rag_id": rag_id,
+                "azure_doc_id": azure_doc_id
+            })
+        return response_sources
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/{source_id}")
+async def delete_source(
+    source_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    source = db.query(db_models.Source).filter(
+        db_models.Source.id == source_id,
+        db_models.Source.user_id == current_user.id
+    ).first()
+    
+    if not source:
+        raise HTTPException(status_code=404, detail="Source not found")
+    
+    try:
+        # 1. Handle RAG Document (Delete completely as it's useless without the source)
+        rag_doc = db.query(db_models.RAGDocument).filter(
+            db_models.RAGDocument.source_id == source.id
+        ).first()
+        
+        if rag_doc:
+            # Delete from Azure Search
+            rag_service.delete_document(rag_doc.azure_doc_id)
+            # Delete from DB
+            db.delete(rag_doc)
+
+        # 2. Handle other dependencies (Delete everything linked to this source)
+        # We must delete children (Flashcards, Questions) before parents (Sets) because of SQL constraints
+        
+        # Delete Flashcards
+        flashcard_set_ids = [s.id for s in db.query(db_models.FlashcardSet).filter(db_models.FlashcardSet.source_id == source.id).all()]
+        if flashcard_set_ids:
+            db.query(db_models.Flashcard).filter(db_models.Flashcard.flashcard_set_id.in_(flashcard_set_ids)).delete(synchronize_session=False)
+        
+        # Delete Quiz Questions
+        quiz_set_ids = [s.id for s in db.query(db_models.QuizSet).filter(db_models.QuizSet.source_id == source.id).all()]
+        if quiz_set_ids:
+            db.query(db_models.QuizQuestion).filter(db_models.QuizQuestion.quiz_set_id.in_(quiz_set_ids)).delete(synchronize_session=False)
+
+        # Now delete the sets and other items
+        db.query(db_models.MindMap).filter(db_models.MindMap.source_id == source.id).delete()
+        db.query(db_models.FlashcardSet).filter(db_models.FlashcardSet.source_id == source.id).delete()
+        db.query(db_models.QuizSet).filter(db_models.QuizSet.source_id == source.id).delete()
+        db.query(db_models.Report).filter(db_models.Report.source_id == source.id).delete()
+        db.query(db_models.VideoSummary).filter(db_models.VideoSummary.source_id == source.id).delete()
+        
+        db.commit() # Commit deletions 
+
+        # 3. Delete from S3
+        await s3_service.delete_file(source.s3_key)
+        
+        # 4. Delete the Source itself from Database
+        db.delete(source)
+        db.commit()
+        
+        return {"message": "Source and all associated generated content (mind maps, quizzes, etc.) deleted successfully."}
+        
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Failed to delete source: {str(e)}")

api/video_generator.py

@@ -0,0 +1,133 @@
+import logging
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from typing import List
+
+from api.auth import get_current_user
+from models import db_models
+from models.schemas import VideoSummaryGenerateRequest, VideoSummaryResponse
+from core.database import get_db
+from services.video_generator_service import video_generator_service
+from services.slides_video_service import slides_video_service
+from services.s3_service import s3_service
+
+router = APIRouter(prefix="/api/videos", tags=["video-generator"])
+logger = logging.getLogger(__name__)
+
+@router.post("/generate", response_model=VideoSummaryResponse)
+async def generate_video_summary(
+    request: VideoSummaryGenerateRequest,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Analyzes a PDF and generates a narrated video summary.
+    """
+    try:
+        # Check source ownership
+        source = db.query(db_models.Source).filter(
+            db_models.Source.s3_key == request.file_key,
+            db_models.Source.user_id == current_user.id
+        ).first()
+        
+        if not source:
+            raise HTTPException(status_code=403, detail="Not authorized to access this file")
+
+        if request.use_slides_transformation:
+            # Full PDF -> Slides -> Video pipeline
+            result = await slides_video_service.generate_transformed_video_summary(
+                file_key=request.file_key,
+                language=request.language,
+                voice_name=request.voice_name,
+                custom_prompt=request.custom_prompt
+            )
+        else:
+            # Standard PDF -> Video pipeline (high fidelity version)
+            result = await video_generator_service.generate_video_summary(
+                file_key=request.file_key,
+                language=request.language,
+                voice_name=request.voice_name
+            )
+
+        # Save to DB
+        db_summary = db_models.VideoSummary(
+            title=result["title"],
+            s3_key=result["s3_key"],
+            s3_url=result["s3_url"],
+            user_id=current_user.id,
+            source_id=source.id
+        )
+        db.add(db_summary)
+        db.commit()
+        db.refresh(db_summary)
+
+        return {
+            "id": db_summary.id,
+            "title": db_summary.title,
+            "s3_key": db_summary.s3_key,
+            "public_url": db_summary.s3_url,
+            "private_url": s3_service.get_presigned_url(db_summary.s3_key),
+            "created_at": db_summary.created_at
+        }
+
+    except Exception as e:
+        logger.error(f"Video summary endpoint failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.get("/list", response_model=List[VideoSummaryResponse])
+async def list_video_summaries(
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Lists all generated video summaries for the current user.
+    """
+    try:
+        summaries = db.query(db_models.VideoSummary).filter(
+            db_models.VideoSummary.user_id == current_user.id
+        ).order_by(db_models.VideoSummary.created_at.desc()).all()
+        
+        return [
+            {
+                "id": s.id,
+                "title": s.title,
+                "s3_key": s.s3_key,
+                "public_url": s.s3_url,
+                "private_url": s3_service.get_presigned_url(s.s3_key),
+                "created_at": s.created_at
+            }
+            for s in summaries
+        ]
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.delete("/{video_id}")
+async def delete_video_summary(
+    video_id: int,
+    current_user: db_models.User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    """
+    Deletes a specific video summary from database and S3.
+    """
+    summary = db.query(db_models.VideoSummary).filter(
+        db_models.VideoSummary.id == video_id,
+        db_models.VideoSummary.user_id == current_user.id
+    ).first()
+    
+    if not summary:
+        raise HTTPException(status_code=404, detail="Video summary not found")
+    
+    try:
+        # 1. Delete from S3
+        await s3_service.delete_file(summary.s3_key)
+        
+        # 2. Delete from DB
+        db.delete(summary)
+        db.commit()
+        
+        return {"message": "Video summary and associated S3 file deleted successfully"}
+    except Exception as e:
+        db.rollback()
+        logger.error(f"Failed to delete video summary: {e}")
+        raise HTTPException(status_code=500, detail=f"Deletion failed: {str(e)}")

assets/bgm/BGM_1.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:246a19adcdc9adacdfe15ba2883848a386e62d25a2cd53c4114b5ebecd4f8b98
+size 3681612

assets/bgm/BGM_2.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ca72c65ec30957233829d9b55715d3b7bf69ad19ae7c236abeed920c15745f12
+size 4039174

assets/bgm/BGM_3.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e597d3338700f45f8869287ff3327df6e8fde3580c37ffa1bca916fb3b5f3ff
+size 4910897

core/config.py

@@ -0,0 +1,50 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from typing import Optional
+
+class Settings(BaseSettings):
+    # AWS Settings
+    AWS_ACCESS_KEY_ID: Optional[str] = None
+    AWS_SECRET_ACCESS_KEY: Optional[str] = None
+    AWS_REGION: str = "us-east-1"
+    AWS_S3_BUCKET: Optional[str] = None
+
+    # Security
+    SECRET_KEY: str = "supersecret-placeholder"
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+
+    # LLM Keys
+    OPENAI_API_KEY: Optional[str] = None
+    GEMINI_API_KEY: Optional[str] = None
+
+    # Database
+    DATABASE_URL: Optional[str] = None
+
+    # Google / Transformation Settings
+    GOOGLE_OAUTH_CLIENT_SECRETS: Optional[str] = None
+    GOOGLE_OAUTH_TOKEN: Optional[str] = None
+    GOOGLE_OAUTH_TOKEN_JSON: Optional[str] = None
+    GCS_BUCKET: Optional[str] = None
+    GCP_SA_JSON: Optional[str] = None
+    GEMINI_USE_VERTEX: Optional[str] = None
+    GCP_PROJECT: Optional[str] = None
+    GCP_LOCATION: Optional[str] = None
+    DRIVE_FOLDER_ID: Optional[str] = None
+
+    # Azure RAG Settings
+    AZURE_SEARCH_KEY: Optional[str] = None
+    AZURE_SEARCH_INDEX_NAME: Optional[str] = None
+    BLOB_CONNECTION_STRING: Optional[str] = None
+    BLOB_CONTAINER_NAME: Optional[str] = None
+    AZURE_SEARCH_ENDPOINT: Optional[str] = None
+    AZURE_OPENAI_ENDPOINT: Optional[str] = None
+    AZURE_OPENAI_API_KEY: Optional[str] = None
+    AZURE_OPENAI_DEPLOYMENT_NAME: Optional[str] = None
+    AZURE_OPENAI_API_VERSION: Optional[str] = None
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        extra="ignore"
+    )
+
+settings = Settings()

core/constants.py

@@ -0,0 +1,106 @@
+# --- Common ---
+LANGUAGES = [
+    {"value": "English", "label": "English"},
+    {"value": "Japanese", "label": "Japanese"}
+]
+
+DIFFICULTIES = [
+    {"value": "easy", "label": "Easy"},
+    {"value": "medium", "label": "Medium"},
+    {"value": "hard", "label": "Hard"}
+]
+
+# --- Podcast ---
+PODCAST_VOICES = [
+    {"value": "Zephyr", "label": "Zephyr"},
+    {"value": "Puck", "label": "Puck"},
+    {"value": "Charon", "label": "Charon"},
+    {"value": "Kore", "label": "Kore"},
+    {"value": "Fenrir", "label": "Fenrir"},
+    {"value": "Leda", "label": "Leda"},
+    {"value": "Orus", "label": "Orus"},
+    {"value": "Aoede", "label": "Aoede"},
+    {"value": "Callirrhoe", "label": "Callirrhoe"},
+    {"value": "Autonoe", "label": "Autonoe"},
+    {"value": "Enceladus", "label": "Enceladus"},
+    {"value": "Iapetus", "label": "Iapetus"},
+    {"value": "Umbriel", "label": "Umbriel"},
+    {"value": "Algieba", "label": "Algieba"},
+    {"value": "Despina", "label": "Despina"},
+    {"value": "Erinome", "label": "Erinome"},
+    {"value": "Algenib", "label": "Algenib"},
+    {"value": "Rasalgethi", "label": "Rasalgethi"},
+    {"value": "Laomedeia", "label": "Laomedeia"},
+    {"value": "Achernar", "label": "Achernar"},
+    {"value": "Alnilam", "label": "Alnilam"},
+    {"value": "Schedar", "label": "Schedar"},
+    {"value": "Gacrux", "label": "Gacrux"},
+    {"value": "Pulcherrima", "label": "Pulcherrima"},
+    {"value": "Achird", "label": "Achird"},
+    {"value": "Zubenelgenubi", "label": "Zubenelgenubi"},
+    {"value": "Vindemiatrix", "label": "Vindemiatrix"},
+    {"value": "Sadachbia", "label": "Sadachbia"},
+    {"value": "Sadaltager", "label": "Sadaltager"},
+    {"value": "Sulafat", "label": "Sulafat"}
+]
+
+PODCAST_BGM = [
+    {"value": "No BGM", "label": "No BGM"},
+    {"value": "BGM 1", "label": "Background Music 1"},
+    {"value": "BGM 2", "label": "Background Music 2"},
+    {"value": "BGM 3", "label": "Background Music 3"}
+]
+
+PODCAST_FORMATS = [
+    {"value": "deep dive", "label": "Deep Dive"},
+    {"value": "debate", "label": "Debate"},
+    {"value": "summary", "label": "Summary"},
+    {"value": "tutorial", "label": "Tutorial"},
+    {"value": "interview", "label": "Interview"}
+]
+
+# --- Flashcards ---
+FLASHCARD_QUANTITIES = [
+    {"value": "fewer", "label": "Fewer (15-20)"},
+    {"value": "standard", "label": "Standard (35-40)"},
+    {"value": "more", "label": "More (55-70)"}
+]
+
+# --- Quizzes ---
+QUIZ_COUNTS = [
+    {"value": "FEWER", "label": "Fewer (5 Questions)"},
+    {"value": "STANDARD", "label": "Standard (10 Questions)"},
+    {"value": "MORE", "label": "More (20 Questions)"}
+]
+
+# --- Reports ---
+REPORT_FORMAT_OPTIONS = [
+    {
+        "value": "briefing_doc", 
+        "label": "Briefing Document", 
+        "description": "Overview of your sources featuring key insights and quotes.",
+        "prompt": "Create a comprehensive briefing document that synthesizes the main themes and ideas from the sources. Start with a concise Executive Summary that presents the most critical takeaways upfront. The body of the document must provide a detailed and thorough examination of the main themes, evidence, and conclusions found in the sources. This analysis should be structured logically with headings and bullet points to ensure clarity. The tone must be objective and incisive.",
+        "prompt_jp": "提供されたソースから主要なテーマとアイデアを統合した包括的なブリーフィング文書を作成してください。最も重要な要点を最初に提示する簡潔なエグゼクティブサマリーから始めてください。文書の本文では、ソースで見つかった主要なテーマ、証拠、結論の詳細で徹底的な検討を提供する必要があります。この分析は、明確さを確保するために見出しと箇条書きで論理的に構成される必要があります。トーンは客観的で鋭いものでなければなりません。"
+    },
+    {
+        "value": "study_guide", 
+        "label": "Study Guide", 
+        "description": "Short-answer quiz, suggested essay questions, and glossary of key terms.",
+        "prompt": "You are a highly capable research assistant and tutor. Create a detailed study guide designed to review understanding of the sources. Create a quiz with ten short-answer questions (2-3 sentences each) and include a separate answer key. Suggest five essay format questions, but do not supply answers. Also conclude with a comprehensive glossary of key terms with definitions.",
+        "prompt_jp": "あなたは非常に有能な研究助手兼家庭教師です。ソースの理解を復習するために設計された詳細な学習ガイドを作成してください。10問の短答式クイズ（各2-3文）を作成し、別途解答キーを含めてください。5つのエッセイ形式の質問を提案しますが、答えは提供しないでください。また、定義付きの主要用語の包括的な用語集で締めくくって��ださい。"
+    },
+    {
+        "value": "blog_post", 
+        "label": "Blog Post", 
+        "description": "Insightful takeaways distilled into a highly readable article.",
+        "prompt": "Act as a thoughtful writer and synthesizer of ideas, tasked with creating an engaging and readable blog post for a popular online publishing platform known for its clean aesthetic and insightful content. Your goal is to distill the top most surprising, counter-intuitive, or impactful takeaways from the provided source materials into a compelling listicle. The writing style should be clean, accessible, and highly scannable, employing a conversational yet intelligent tone. Craft a compelling, click-worthy headline. Begin the article with a short introduction that hooks the reader by establishing a relatable problem or curiosity, then present each of the takeaway points as a distinct section with a clear, bolded subheading. Within each section, use short paragraphs to explain the concept clearly, and don't just summarize; offer a brief analysis or a reflection on why this point is so interesting or important, and if a powerful quote exists in the sources, feature it in a blockquote for emphasis. Conclude the post with a brief, forward-looking summary that leaves the reader with a final thought-provoking question or a powerful takeaway to ponder.",
+        "prompt_jp": "清潔な美学と洞察に富んだコンテンツで知られる人気のオンライン出版プラットフォーム向けに、魅力的で読みやすいブログ記事を作成することを任された、思慮深いライター兼アイデアの統合者として行動してください。あなたの目標は、提供されたソース資料から最も驚くべき、直感に反する、または影響力のある要点を、魅力的なリスト記事に蒸留することです。文章スタイルは清潔で、親しみやすく、非常にスキャンしやすいもので、会話的でありながら知的なトーンを採用してください。魅力的でクリックしたくなる見出しを作成してください。読者を引き込む短い紹介で記事を始め、親しみやすい問題や好奇心を確立し、その後、各要点を明確で太字の小見出しを持つ別個のセクションとして提示してください。各セクション内では、短い段落を使用して概念を明確に説明し、単に要約するだけでなく、なぜこの点がそれほど興味深いのか、または重要なのかについての簡潔な分析や考察を提供し、ソースに強力な引用が存在する場合は、強調のためにブロッククォートで紹介してください。読者に最終的な思考を促す質問や強力な要点を残す簡潔で前向きな要約で記事を締めくくってください。"
+    },
+    {
+        "value": "custom", 
+        "label": "Custom Prompt", 
+        "description": "Generate a report based on your specific instructions.",
+        "prompt": "",
+        "prompt_jp": ""
+    }
+]

core/database.py

@@ -0,0 +1,32 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from .config import settings
+
+# For Azure SQL, we use the DATABASE_URL from .env
+# If not provided, fallback to a local sqlite for safety (optional)
+SQLALCHEMY_DATABASE_URL = settings.DATABASE_URL or "sqlite:///./temp.db"
+
+# Create engine with stability settings for Azure SQL
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL,
+    pool_pre_ping=True,    # Check connection health before every query
+    pool_recycle=300,      # Refresh connections every 5 minutes
+    pool_size=10,          # Maintain up to 10 connections
+    max_overflow=20        # Allow 20 extra if busy
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()
+
+def init_db():
+    import models.db_models  # Ensure models are loaded
+    Base.metadata.create_all(bind=engine)

core/prompts.py

@@ -0,0 +1,573 @@
+SYSTEM_PROMPT = """
+You are a professional podcast scriptwriter creating a natural, engaging Japanese podcast conversation.
+
+────────────────────────
+1. Speaker Roles (CRITICAL)
+────────────────────────
+- Use ONLY:
+  - Speaker 1: Curious host and listener representative
+  - Speaker 2: Calm expert and explainer
+- Speakers must strictly alternate.
+- Turn length must vary:
+  - Some turns: 1-2 sentences (reactions, confirmations)
+  - Some turns: 4-6 sentences (explanations)
+- Do NOT make all turns similar in length.
+- Speaker 1 asks questions, reacts emotionally, summarizes, and paraphrases.
+- Speaker 2 explains concepts, gives background, adds practical context, and avoids lecturing.
+
+────────────────────────
+1.5 Conversational Dynamics (MANDATORY)
+────────────────────────
+- Speaker 1 must occasionally:
+  - Misinterpret a concept slightly
+  - Ask a naive or overly simplified question
+  - React emotionally before fully understanding
+- Speaker 2 must:
+  - Gently correct or reframe Speaker 1's understanding
+  - Use analogies or metaphors when concepts get abstract
+- At least once per major topic:
+  - Speaker 1 interrupts with a short reaction (1-2 sentences)
+  - Speaker 2 adjusts the explanation in response
+
+────────────────────────
+2. Length & Coverage
+────────────────────────
+- Total length MUST be {target_words} Japanese words (±10%).
+- Do NOT summarize the PDF.
+- Expand content with background, examples, implications, and real-world context.
+- Include as much detail from the PDF as possible.
+- Do NOT mention page numbers.
+- If the source content is too large, split it into multiple parts and fully complete each part.
+
+────────────────────────
+3. Conversation Flow (MANDATORY)
+────────────────────────
+Follow this flow naturally (do NOT label sections):
+
+1. Friendly greetings and a clear statement of today's topic
+2. Introduction of “Today's Talk Topics”
+3. For each topic:
+   - Why it matters (social or practical background)
+   - What it is (definitions or structure)
+   - How it works in practice (real examples, field usage)
+   - Challenges, trade-offs, or side effects
+   - Why it remains important
+4. Gentle recap of key ideas
+5. Short teaser for the next episode
+
+────────────────────────
+4. Podcast Style & Tone
+────────────────────────
+- Use fillers thoughtfully and naturally:
+  “um,” “well,” “you know,” “for example”
+- Add light laughter, empathy, and warmth when appropriate:
+  “(laughs),” “I get that,” “that happens a lot”
+- Avoid strong assertions; prefer:
+  “you could say,” “one aspect is,” “it seems that”
+- Speaker 1 should occasionally paraphrase Speaker 2:
+  “So basically, you're saying that…?”
+
+────────────────────────
+5. Restrictions
+────────────────────────
+- No URLs, no bullet points, no metadata, no code.
+- Output ONLY the podcast script text.
+- Keep the tone friendly, polite, and suitable for audio listening.
+
+────────────────────────
+6. Source Material
+────────────────────────
+- Use {pdf_suggestions} as inspiration and factual grounding.
+- Podcast format: {podcast_format}
+
+Output example:
+Speaker 1: Hello everyone, today we're talking about...
+Speaker 2: That's a great topic. Well, if we look at the background...
+"""
+
+
+ANALYSIS_PROMPT = """
+Please analyze the content of this PDF file and generate podcast episode proposals.
+        
+IMPORTANT: The target podcast duration is {duration_minutes} minutes. Please structure the program accordingly:
+- For {duration_minutes} minutes, plan approximately words total (500 words per minute)
+- Adjust the depth and detail of each section based on the available time
+- Ensure the program structure fits comfortably within the {duration_minutes} minute timeframe
+
+Analysis & Output Requirements
+1. Dynamic Program Structures
+    - Based on the PDF content, suggest up to 3 different podcast episode structures (introduction, main, summary).
+    - based on user time requirement, suggest the structure.
+
+2. Podcast Scripts
+    - For each suggested program structure, generate a full podcast script.
+    - The script length should correspond to the user time requirement.
+    - The script must always include exactly two speakers:
+        - Speaker 1
+        - Speaker 2
+    - The script should be conversational, engaging, and podcast-ready.
+
+Output Requirements
+    - Output must be in Japanese .
+    - Provide 2-3 different podcast episode proposals.
+    - Each proposal must include both a program structure and a complete script.
+    - Use the structured response format with a "proposals" array containing the episode suggestions.
+
+4. Constraints 
+    - Maximum 3 suggestions only.
+    - Always provide both Program Structure and Script for each suggestion.
+    - Ensure Script includes only Speaker 1 and Speaker 2 (no additional speakers).
+    - Use natural Japanese  conversation style.
+    - Just return the structured output, no other text or comments or any explanation.
+"""
+
+
+def get_flashcard_system_prompt(
+    difficulty: str = "medium", 
+    quantity: str = "standard",
+    language: str = "Japanese"
+) -> str:
+    # Language-specific instructions
+    if language == "Japanese":
+        language_instruction = """
+LANGUAGE: JAPANESE
+- Generate all flashcards in Japanese language
+- Use appropriate Japanese terminology and expressions
+- Ensure questions and answers are natural and clear in Japanese
+- Use polite form (です/ます) for formal educational content"""
+    else:  # English
+        language_instruction = """
+LANGUAGE: ENGLISH
+- Generate all flashcards in English language
+- Use clear, professional English terminology
+- Ensure questions and answers are grammatically correct and natural
+- Use appropriate academic language for educational content"""
+
+    # Core instructions for flashcard generation
+    base_prompt = f"""You are an expert educational content creator specializing in creating high-quality flashcards from PDF documents. Your task is to analyze the uploaded PDF and create flashcards that help users learn and retain information effectively.
+
+{language_instruction}
+
+IMPORTANT INSTRUCTIONS:
+1. Read and analyze the entire PDF document thoroughly
+2. Extract key concepts, definitions, facts, and important information
+3. Create flashcards that follow the question-answer format
+4. Ensure questions are clear, specific, and test understanding
+5. Provide concise but complete answers
+6. Cover the most important topics from the document
+7. Return ONLY a JSON array of flashcards in the exact format specified below
+
+REQUIRED JSON FORMAT:
+[
+    {{
+        "question": "Your question here",
+        "answer": "Your answer here"
+    }},
+    {{
+        "question": "Another question",
+        "answer": "Another answer"
+    }}
+]
+
+DO NOT include any text before or after the JSON array. Return ONLY the JSON."""
+
+    # Configure difficulty-specific instructions based on user selection
+    if difficulty == "easy":
+        difficulty_instructions = """
+
+DIFFICULTY LEVEL: EASY
+- Create simple, straightforward questions
+- Focus on basic facts, definitions, and key terms
+- Use simple language and avoid complex concepts
+- Questions should test recall and basic understanding
+- Answers should be concise (1-2 sentences maximum)"""
+    
+    elif difficulty == "hard":
+        difficulty_instructions = """
+
+DIFFICULTY LEVEL: HARD
+- Create challenging, analytical questions
+- Focus on complex concepts, relationships, and applications
+- Test deep understanding and critical thinking
+- Include scenario-based and comparative questions
+- Answers can be more detailed (2-4 sentences)"""
+    
+    else:  # medium (default)
+        difficulty_instructions = """
+
+DIFFICULTY LEVEL: MEDIUM
+- Create balanced questions that test both recall and understanding
+- Mix factual questions with conceptual ones
+- Include some application-based questions
+- Use moderate complexity in language and concepts
+- Answers should be informative but concise (1-3 sentences)"""
+
+    # Configure quantity-specific instructions based on user selection
+    if quantity == "fewer":
+        quantity_instructions = """
+
+QUANTITY: FEWER (15-20 flashcards)
+- Focus on the most essential and fundamental concepts
+- Prioritize the core topics that users must know
+- Create comprehensive coverage of key themes
+- Ensure each flashcard covers critical information"""
+    
+    elif quantity == "more":
+        quantity_instructions = """
+
+QUANTITY: MORE (55-70 flashcards)
+- Create comprehensive coverage of the document
+- Include both major and minor concepts
+- Cover details, examples, and supporting information
+- Create flashcards for specific facts, dates, names, and procedures
+- Ensure thorough coverage of all important topics"""
+    
+    else:  # standard (default)
+        quantity_instructions = """
+
+QUANTITY: STANDARD (35-40 flashcards)
+- Provide balanced coverage of important topics
+- Include both core concepts and important details
+- Mix fundamental and intermediate-level questions
+- Cover the most significant information comprehensively"""
+
+    return base_prompt + difficulty_instructions + quantity_instructions
+
+
+def get_flashcard_topic_prompt(topic: str) -> str:
+    if not topic or topic.strip() == "":
+        return ""
+    
+    return f"""
+
+TOPIC FOCUS: {topic}
+- Prioritize flashcards related to the specified topic: "{topic}"
+- Ensure at least 70% of flashcards directly relate to this topic
+- If the topic is not well-covered in the document, focus on the most relevant related concepts
+- Maintain the specified difficulty and quantity requirements"""
+
+
+def get_flashcard_explanation_prompt(question: str, language: str = "Japanese") -> str:
+    # Language-specific instructions for explanations
+    if language == "Japanese":
+        language_instruction = """
+LANGUAGE: JAPANESE
+- Provide the explanation in Japanese language
+- Use appropriate Japanese terminology and expressions
+- Ensure the explanation is natural and clear in Japanese
+- Use polite form (です/ます) for formal educational content"""
+    else:  # English
+        language_instruction = """
+LANGUAGE: ENGLISH
+- Provide the explanation in English language
+- Use clear, professional English terminology
+- Ensure the explanation is grammatically correct and natural
+- Use appropriate academic language for educational content"""
+
+    # Create comprehensive explanation prompt with PDF context
+    return f"""You are an expert tutor. Based on the uploaded PDF document, provide a detailed explanation for the following question:
+
+{language_instruction}
+
+Question: {question}
+
+Please provide:
+1. A clear, comprehensive explanation that helps the student understand the concept
+2. Context from the PDF document that supports the answer
+3. Additional relevant information that enhances understanding
+4. Examples or analogies if helpful
+
+Keep the explanation educational and detailed, drawing specifically from the PDF content."""
+
+
+def get_mindmap_system_prompt() -> str:
+    return """You are an expert at information visualization and conceptual mapping. Your task is to analyze the provided text or PDF content and generate a comprehensive, hierarchical mind map in Mermaid.js 'mindmap' format.
+
+INSTRUCTIONS:
+1. Identify the central theme and use it as the root node.
+2. Extract major categories as first-level branches.
+3. Add detailed sub-topics and key facts as supporting branches.
+4. Keep node text concise (1-4 words).
+5. Ensure the hierarchy is logical and easy to follow.
+6. Use Mermaid 'mindmap' syntax.
+
+EXAMPLE FORMAT:
+mindmap
+  root((Central Topic))
+    Topic A
+      Subtopic A1
+      Subtopic A2
+    Topic B
+      Subtopic B1
+
+IMPORTANT: 
+- Return ONLY the Mermaid code block starting with 'mindmap'.
+- Do NOT include any introductory or concluding text.
+- Use indentation (2 spaces) to define hierarchy.
+- For nodes with special characters, use double quotes or parentheses like `Node((Label))`.
+"""
+
+
+def get_quiz_system_prompt(language: str = "Japanese") -> str:
+    if language.lower() == "japanese":
+        return """
+あなたは優秀なクイズ作成AIです。アップロードされた内容を分析し、指定された「難易度」や「トピック」に基づいて日本語でクイズを作成してください。
+
+絶対条件（厳守）:
+- 出力は常に下記のJSON形式のみ。
+- 全ての問題の「answer」は、"1"〜"4" ができるだけ均等に出現するようにします。
+- 同じ番号が3問以上連続しないようにしてください。
+
+出力形式（この形のみ）:
+{
+  "quizzes": [
+    {
+      "question": "問題文",
+      "hint": "ヒント",
+      "choices": { "1": "選択肢1", "2": "選択肢2", "3": "選択肢3", "4": "選択肢4" },
+      "answer": "1|2|3|4 のいずれか",
+      "explanation": "正解の詳細な説明"
+    }
+  ]
+}
+
+作成方針:
+1) 各設問について、内容に基づく正解を決め、その正解の内容をランダムな番号の位置に置く。他の選択肢は紛らわしいが誤りの内容にする。
+2) explanation には根拠と理由を記載。
+3) hint は正解を直接言わずに、考えさせるような内容にする。
+4) 質問文は明確かつ簡潔に、選択肢は適切な長さに。
+
+JSON 以外は一切出力しないでください。
+"""
+    else:
+        return """
+You are an excellent quiz-creation AI. Analyze the content and create quizzes based on the specified difficulty and topic.
+
+Hard requirements:
+- Output ONLY the JSON structure below.
+- Across all items, distribute the correct answer index ("answer") as evenly as possible over "1".."4".
+- Do NOT allow the same answer index to appear 3+ times in a row.
+
+Output format (and nothing else):
+{
+  "quizzes": [
+    {
+      "question": "Question",
+      "hint": "Hint",
+      "choices": { "1": "Choice 1", "2": "Choice 2", "3": "Choice 3", "4": "Choice 4" },
+      "answer": "1|2|3|4",
+      "explanation": "Detailed reasoning for why this is correct"
+    }
+  ]
+}
+
+Creation protocol:
+1) For each quiz, determine the correct content and place it at a random position from 1-4, adjusting other distractors accordingly.
+2) explanation must include reasoning grounded in the source content.
+3) hint should be helpful without giving away the answer directly.
+4) Keep questions clear; choices concise.
+
+Do not output anything except the JSON.
+"""
+
+
+from core import constants
+
+def get_report_prompt(format_key: str, custom_prompt: str = "", language: str = "Japanese") -> str:
+    if format_key == "custom":
+        return custom_prompt
+
+    # Search in constants
+    for option in constants.REPORT_FORMAT_OPTIONS:
+        if option["value"] == format_key:
+            if language == "Japanese":
+                return option["prompt_jp"]
+            else:
+                return option["prompt"]
+
+    return custom_prompt
+
+def get_report_suggestion_prompt(language: str = "Japanese") -> str:
+    if language == "Japanese":
+        return FORMAT_SUGGESTION_PROMPT_JP + "\n\n重要: すべての提案とプロンプトは日本語で書いてください。"
+    else:
+        return FORMAT_SUGGESTION_PROMPT + "\n\nIMPORTANT: Write all suggestions and prompts in English."
+
+
+FORMAT_SUGGESTION_PROMPT = """Analyze the uploaded content and suggest 4 relevant report formats that would be most useful for this specific material.
+
+For each suggested format, provide:
+1. A descriptive name (2-4 words)
+2. A brief description of what the report would contain
+3. A detailed prompt for generating that specific report
+
+Return the response as a JSON object with this structure:
+{
+    "suggestions": [
+        {
+            "name": "Format Name",
+            "description": "Brief description",
+            "prompt": "Detailed prompt for generating this report"
+        }
+    ]
+}"""
+
+FORMAT_SUGGESTION_PROMPT_JP = """アップロードされた内容を分析し、この特定の資料に最も有用な4つの関連レポート形式を提案してください。
+
+各提案された形式について、以下を提供してください：
+1. 説明的な名前（2-4語）
+2. レポートに含まれる内容の簡潔な説明
+3. その特定のレポートを生成するための詳細なプロンプト
+
+以下の構造のJSONオブジェクトとして応答を返してください：
+{
+    "suggestions": [
+        {
+            "name": "形式名",
+            "description": "簡潔な説明",
+            "prompt": "このレポートを生成するための詳細なプロンプト"
+        }
+    ]
+}"""
+
+
+
+
+def get_pdf_text_extraction_prompt() -> str:    
+    return """You are an expert text extraction assistant. You have been provided with a PDF document.
+
+    **Task**: Extract all text content from this PDF document.
+
+    **Requirements**:
+    1. Extract all text content from the PDF in a structured manner
+    2. Preserve the logical flow and hierarchy of information
+    3. Maintain section headers, main topics, and subtopics
+
+    **Output Format**:
+    Return the extracted text as plain text with proper formatting:
+    - Use clear paragraph breaks
+    - Maintain heading structure
+    - Keep bullet points or numbered lists intact
+    - Preserve important formatting that conveys meaning
+
+    **Important**:
+    - Do NOT add any additional commentary or explanations
+    - Do NOT summarize - extract the full content
+    - Just return the extracted text content
+    - Make sure the text is complete and can be used for presentation generation"""
+
+
+def get_video_script_prompt(language: str, total_pages: int) -> str:
+    """
+    Generate high-fidelity prompt for PDF script generation.
+    """
+    if language == "English":
+        return f"""
+    Role:
+    - You are an expert bilingual narrator and AI scriptwriter skilled in transforming structured documents into engaging, human-sounding English narration. Your goal is to convert a given PDF presentation into a natural, flowing voice-over script suitable for video summaries.
+
+    Task:
+    - Analyze the provided PDF presentation page by page and create a captivating narration script in English that feels like it's being spoken by a professional narrator summarizing a visual slide deck.
+
+    Guidelines:
+    - Carefully read each page's main content and summarize it.
+    - Create a natural, flowing narration script that doesn't sound robotic.
+    - Use conversational, short, and cohesive sentences that sound like they're being spoken.
+    - Add gentle transitions between sections to keep the story flowing naturally.
+    - Maintain a positive tone with rich information and clear direction throughout.
+    - All text (including page titles and key points) should be in English .
+    - Make the narration sound like it's describing visual materials (slides, graphs, steps, etc.) to the listener.
+    - Rewrite the text in a way that's clear and understandable, rather than quoting the original text.
+
+    Output Format (strict JSON only):
+    {{
+      "total_pages": {total_pages},
+      "scripts": [
+        {{
+          "page_number": 1,
+          "page_title": "",
+          "script_text": "",
+          "key_points": [],
+          "duration_estimate": ""
+        }}
+      ],
+      "total_duration_estimate": "about 3-4 minutes"
+    }}
+
+    Important Notes:
+    - Output must be valid JSON only, no extra commentary or Markdown.
+    - Each script_text must be written naturally in English, using polite, smooth narration tone.
+    - duration_estimate values should be realistic for natural speech.
+    """
+    else:  # Japanese
+        return f"""
+    役割：
+      - あなたはバイリンガルのナレーター兼AIスクリプトライターであり、構造化されたドキュメントを魅力的で自然な日本語のナレーションに変換できます。目標は、提供されたPDFプレゼンテーションを、動画に適した自然で流れるようなナレーションスクリプトに変換することです。
+
+    タスク:
+    - 提供されたPDFプレゼンテーションをページごとに分析し、理解しやすい日本語のナレーションスクリプトを作成してください。
+
+    ガイドライン:
+    - 各ページの主要コンテンツを注意深く読みます。
+    - ロボットのように聞こえない、自然で流れるようなナレーションスクリプトを作成します。
+    - 会話的で、簡潔で、一貫性のあるトーンで、理解しやすいようにします。
+    - 全体の流れを維持するために、セクション間のスムーズな移行を含めます。
+    - 肯定的で、情報を提供し、明確なトーンを維持します。
+    - すべてのテキスト（ページタイトルと重要なポイントを含む）は日本語で記述する必要があります。
+    - 視聴者がスライド、グラフ、手順などを見ているかのように、視覚的な要素を説明します。
+    - 原文を逐語的に引用することは避けてください。明確で自然な書き方に書き換えてください。
+
+   出力フォーマット(厳密なJSONのみ):
+    {{
+      "total_pages": {total_pages},
+      "scripts": [
+        {{
+          "page_number": 1,
+          "page_title": "",
+          "script_text": "",
+          "key_points": [],
+          "duration_estimate": ""
+        }}
+      ],
+      "total_duration_estimate": "約3〜4分"
+    }}
+
+    重要事項:
+    - 出力は有効なJSON形式のみで、不要なコメントやMarkdown形式を含めないでください。
+    - すべてのscript_textは、自然で丁寧な日本語のナレーションスタイルで記述してください。
+    - duration_estimate を実際のナレーションに近い現実的な長さに設定します。
+    """
+
+
+def get_outline_prompt(template_yaml_text: str, source_text: str, custom_prompt: str = "", language: str = "Japanese") -> str:
+    """アウトライン生成用のプロンプト文を構築する。"""
+    extra = (custom_prompt or "").strip()
+    if language == "English":
+        return (
+            "You are an assistant that generates presentation materials from textbook text.\n"
+            "You will be given the following 2 items:\n\n"
+            "1. `TEMPLATE_YAML`: Slide template definitions\n"
+            "2. `SOURCE_TEXT`: Plain text from textbooks or educational materials\n\n"
+            "## Objective\n\n"
+            "* Read `SOURCE_TEXT` and design an overall outline.\n"
+            "* Generate text to fill the placeholders for each selected template.\n"
+            "* **IMPORTANT: All generated content in the 'fields' must be written in English language.**\n"
+            "* Return in JSON format only.\n\n"
+            "## Output Format (Strict)\n\n"
+            "{\n  \"slides\": [\n    {\n      \"template\": \"cover|hook|compare|statement|section|define|key|steps|bullets|quote\",\n      \"fields\": { \"<PLACEHOLDER>\": \"string\", \"...\": \"...\" }\n    }\n  ]\n}\n\n"
+            + ("## Additional Instructions\n\n" + extra + "\n\n" if extra else "")
+            + "## Input\n\n* TEMPLATE_YAML:\n\n" + template_yaml_text + "\n\n* SOURCE_TEXT:\n\n" + source_text
+        )
+    else:
+        return (
+            "あなたは「教科書テキストからプレゼン資料を自動生成する」アシスタントです。\n"
+            "## 目的\n\n"
+            "* `SOURCE_TEXT`を読み、全体のアウトラインを設計。\n"
+            "* 各ページで選んだテンプレのプレースホルダーに入れるテキストを生成。\n"
+            "* **重要: 'fields' 内の全ての生成コンテンツは日本語で記述すること。**\n"
+            "* JSONで返す。\n\n"
+            "## 出力フォーマット（厳守）\n\n"
+            "{\n  \"slides\": [\n    {\n      \"template\": \"cover|hook|compare|statement|section|define|key|steps|bullets|quote\",\n      \"fields\": { \"<PLACEHOLDER>\": \"string\", \"...\": \"...\" }\n    }\n  ]\n}\n\n"
+            + ("## 追加指示\n\n" + extra + "\n\n" if extra else "")
+            + "## 入力\n\n* TEMPLATE_YAML:\n\n" + template_yaml_text + "\n\n* SOURCE_TEXT:\n\n" + source_text
+        )

core/security.py

@@ -0,0 +1,27 @@
+import bcrypt
+from datetime import datetime, timedelta
+from typing import Optional, Any
+from jose import jwt
+from core.config import settings
+
+def create_access_token(data: dict, expires_delta: Optional[timedelta] = None) -> str:
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.utcnow() + expires_delta
+    else:
+        expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt
+
+def verify_password(plain_password: str, hashed_password: str) -> bool:
+    return bcrypt.checkpw(
+        plain_password.encode('utf-8'), 
+        hashed_password.encode('utf-8')
+    )
+
+def get_password_hash(password: str) -> str:
+    pwd_bytes = password.encode('utf-8')
+    salt = bcrypt.gensalt()
+    hashed = bcrypt.hashpw(pwd_bytes, salt)
+    return hashed.decode('utf-8')

core/templates/eng_slide_template.yaml

@@ -0,0 +1,69 @@
+slides_template:
+  - name: cover
+    description: Cover slide. Display the presentation title in a large, centered font.
+    fields:
+      COVER.MAIN: { type: text, max_chars: 40, note: "Recommend a short title. If there is no subtitle, it should be about 20-30 characters." }
+
+  - name: hook
+    description: A question or problem to engage the audience.
+    fields:
+      HOOK.MAIN: { type: text, max_chars: 60, note: "1-2 lines. Questions or impactful expressions." }
+
+  - name: compare
+    description: Compare and contrast in two columns.
+    fields:
+      COMPARE.LEFT:  { type: text, max_chars: 80, note: "The left side's argument or example. Up to 2-3 lines." }
+      COMPARE.RIGHT: { type: text, max_chars: 80, note: "The right side's argument or example. Up to 2-3 lines." }
+
+  - name: statement
+    description: Present a key message in one sentence.
+    fields:
+      STATEMENT.MAIN: { type: text, max_chars: 50, note: "A short sentence. One line of the key message." }
+
+  - name: section
+    description: Section change. Number and main heading.
+    fields:
+      SECTION.NUMBER: { type: text, max_chars: 3, note: "Number like 1, 2, 3." }
+      SECTION.MAIN:   { type: text, max_chars: 30, note: "Section title." }
+
+  - name: define
+    description: Define terms or concepts.
+    fields:
+      DEFINE.TITLE: { type: text, max_chars: 10, note: "Definition title." }
+      DEFINE.MAIN: { type: text, max_chars: 80, note: "Definition sentence. Concisely in 1-2 sentences." }
+
+  - name: key
+    description: A slide to emphasize the key message.
+    fields:
+      KEY.MAIN: { type: text, max_chars: 70, note: "1-2 sentences. Clear and strong expression." }
+
+  - name: steps
+    description: Explain the 3-step process.
+    fields:
+      STEPS.TITLE: { type: text, max_chars: 40 }
+      STEPS.TITLE1: { type: text, max_chars: 25 }
+      STEPS.TITLE2: { type: text, max_chars: 25 }
+      STEPS.TITLE3: { type: text, max_chars: 25 }
+      STEPS.TEXT1: { type: text, max_chars: 60 }
+      STEPS.TEXT2: { type: text, max_chars: 60 }
+      STEPS.TEXT3: { type: text, max_chars: 60 }
+      note: "Each step should be a short phrase."
+
+  - name: bullets
+    description: A bulleted list.
+    fields:
+      BULLETS.TITLE: { type: text, max_chars: 30 }
+      BULLETS.TEXT1: { type: text, max_chars: 40 }
+      BULLETS.TEXT2: { type: text, max_chars: 40 }
+      BULLETS.TEXT3: { type: text, max_chars: 40 }
+      note: "It's easier to read if it's within 3-4 items."
+
+  - name: quote
+    description: A quote or a sentence to emphasize.
+    fields:
+      QUOTE.MAIN: { type: text, max_chars: 50, note: "A quote or a sentence to emphasize. Use a lot of white space." }
+
+  - name: logo
+    description: Display the company logo.
+    fields:
+      LOGO.MAIN: { type: text, fixed_value: "app.at-peak.jp" }

core/templates/ja_slide_template.yaml

@@ -0,0 +1,69 @@
+slides_template:
+  - name: cover
+    description: 表紙スライド。プレゼンタイトルを大きく中央に表示。
+    fields:
+      COVER.MAIN: { type: text, max_chars: 40, note: "短いタイトルを推奨。副題なしなら20〜30文字程度。" }
+
+  - name: hook
+    description: 聴衆を引き込む質問や問題提起。
+    fields:
+      HOOK.MAIN: { type: text, max_chars: 60, note: "1〜2行。疑問形やインパクトある表現。" }
+
+  - name: compare
+    description: 左右2カラムで比較・対比。
+    fields:
+      COMPARE.LEFT:  { type: text, max_chars: 80, note: "左側の主張や例。2〜3行まで。" }
+      COMPARE.RIGHT: { type: text, max_chars: 80, note: "右側の主張や例。2〜3行まで。" }
+
+  - name: statement
+    description: 重要メッセージを1文で提示。
+    fields:
+      STATEMENT.MAIN: { type: text, max_chars: 50, note: "短文。キーメッセージ1行。" }
+
+  - name: section
+    description: セクション切替用。番号と大見出し。
+    fields:
+      SECTION.NUMBER: { type: text, max_chars: 3, note: "1, 2, 3など番号。" }
+      SECTION.MAIN:   { type: text, max_chars: 30, note: "章タイトル。" }
+
+  - name: define
+    description: 用語や概念を定義。
+    fields:
+      DEFINE.TITLE: { type: text, max_chars: 10, note: "定義のタイトル。" }
+      DEFINE.MAIN: { type: text, max_chars: 80, note: "定義文。1〜2文で簡潔に。" }
+
+  - name: key
+    description: キーメッセージを強調するスライド。
+    fields:
+      KEY.MAIN: { type: text, max_chars: 70, note: "1〜2文。明確で力強い表現。" }
+
+  - name: steps
+    description: 3ステップのプロセスを説明。
+    fields:
+      STEPS.TITLE: { type: text, max_chars: 40 }
+      STEPS.TITLE1: { type: text, max_chars: 25 }
+      STEPS.TITLE2: { type: text, max_chars: 25 }
+      STEPS.TITLE3: { type: text, max_chars: 25 }
+      STEPS.TEXT1: { type: text, max_chars: 60 }
+      STEPS.TEXT2: { type: text, max_chars: 60 }
+      STEPS.TEXT3: { type: text, max_chars: 60 }
+      note: "各ステップは短いフレーズ推奨。"
+
+  - name: bullets
+    description: 箇条書きリスト。
+    fields:
+      BULLETS.TITLE: { type: text, max_chars: 30 }
+      BULLETS.TEXT1: { type: text, max_chars: 40 }
+      BULLETS.TEXT2: { type: text, max_chars: 40 }
+      BULLETS.TEXT3: { type: text, max_chars: 40 }
+      note: "3〜4項目以内に収めると見やすい。"
+
+  - name: quote
+    description: 名言や強調したい一文を吹き出し表示。
+    fields:
+      QUOTE.MAIN: { type: text, max_chars: 50, note: "引用1行。余白を広く使う。" }
+
+  - name: logo
+    description: 会社ロゴ表示。
+    fields:
+      LOGO.MAIN: { type: text, fixed_value: "app.at-peak.jp" }

main.py

@@ -0,0 +1,42 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from core.database import init_db
+from api import auth, sources, podcast, flashcards, mindmaps, quizzes, reports, video_generator, rag, chat
+
+# Initialize Database Tables
+init_db()
+
+app = FastAPI(
+    title="CreatorStudio AI API",
+    description="Backend for CreatorStudio AI - Podcast and Content Creation Platform",
+    version="0.1.0"
+)
+
+# CORS Configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include Routers
+app.include_router(auth.router)
+app.include_router(sources.router)
+app.include_router(podcast.router)
+app.include_router(flashcards.router)
+app.include_router(mindmaps.router)
+app.include_router(quizzes.router)
+app.include_router(reports.router)
+app.include_router(video_generator.router)
+app.include_router(rag.router)
+app.include_router(chat.router)
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to CreatorStudio AI API. Head to /docs for API documentation."}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

models/db_models.py

@@ -0,0 +1,161 @@
+from sqlalchemy import Column, Integer, String, Boolean, DateTime, ForeignKey, Float, Text, JSON, Unicode, UnicodeText
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+from core.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    email = Column(Unicode(255), unique=True, index=True, nullable=False)
+    hashed_password = Column(String(255), nullable=False)
+    is_active = Column(Boolean, default=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    sources = relationship("Source", back_populates="owner")
+    podcasts = relationship("Podcast", back_populates="owner")
+    flashcard_sets = relationship("FlashcardSet", back_populates="owner")
+    mind_maps = relationship("MindMap", back_populates="owner")
+    quiz_sets = relationship("QuizSet", back_populates="owner")
+    reports = relationship("Report", back_populates="owner")
+    video_summaries = relationship("VideoSummary", back_populates="owner")
+    rag_documents = relationship("RAGDocument", back_populates="owner")
+    chat_messages = relationship("ChatMessage", back_populates="owner", cascade="all, delete-orphan")
+
+class Source(Base):
+    __tablename__ = "sources"
+
+    id = Column(Integer, primary_key=True, index=True)
+    filename = Column(Unicode(255), nullable=False)
+    s3_key = Column(String(512), nullable=False)
+    s3_url = Column(String(1024), nullable=False)
+    size = Column(Integer)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="sources")
+
+class Podcast(Base):
+    __tablename__ = "podcasts"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(Unicode(255))
+    s3_key = Column(String(512), nullable=False)
+    s3_url = Column(String(1024), nullable=False)
+    script = Column(UnicodeText)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="podcasts")
+
+class FlashcardSet(Base):
+    __tablename__ = "flashcard_sets"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(Unicode(255))
+    difficulty = Column(String(50))
+    user_id = Column(Integer, ForeignKey("users.id"))
+    source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="flashcard_sets")
+    flashcards = relationship("Flashcard", back_populates="flashcard_set", cascade="all, delete-orphan")
+
+class MindMap(Base):
+    __tablename__ = "mind_maps"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(Unicode(255))
+    mermaid_code = Column(UnicodeText, nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="mind_maps")
+
+class QuizSet(Base):
+    __tablename__ = "quiz_sets"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(Unicode(255))
+    difficulty = Column(String(50))
+    user_id = Column(Integer, ForeignKey("users.id"))
+    source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="quiz_sets")
+    questions = relationship("QuizQuestion", back_populates="quiz_set", cascade="all, delete-orphan")
+
+class QuizQuestion(Base):
+    __tablename__ = "quiz_questions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    quiz_set_id = Column(Integer, ForeignKey("quiz_sets.id"))
+    question = Column(UnicodeText, nullable=False)
+    hint = Column(UnicodeText)
+    choices = Column(JSON, nullable=False) # Store choices as a JSON object {"1": "...", "2": "...", ...}
+    answer = Column(String(10), nullable=False) # Storing "1", "2", "3", or "4"
+    explanation = Column(UnicodeText)
+
+    quiz_set = relationship("QuizSet", back_populates="questions")
+
+class Report(Base):
+    __tablename__ = "reports"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(Unicode(255))
+    content = Column(UnicodeText, nullable=False)
+    format_key = Column(String(100))
+    user_id = Column(Integer, ForeignKey("users.id"))
+    source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="reports")
+
+class VideoSummary(Base):
+    __tablename__ = "video_summaries"
+
+    id = Column(Integer, primary_key=True, index=True)
+    title = Column(Unicode(255))
+    s3_key = Column(String(512), nullable=False)
+    s3_url = Column(String(1024), nullable=False)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="video_summaries")
+
+class Flashcard(Base):
+    __tablename__ = "flashcards"
+
+    id = Column(Integer, primary_key=True, index=True)
+    flashcard_set_id = Column(Integer, ForeignKey("flashcard_sets.id"))
+    question = Column(UnicodeText, nullable=False)
+    answer = Column(UnicodeText, nullable=False)
+
+    flashcard_set = relationship("FlashcardSet", back_populates="flashcards")
+
+class RAGDocument(Base):
+    __tablename__ = "rag_documents"
+
+    id = Column(Integer, primary_key=True, index=True)
+    filename = Column(Unicode(255), nullable=False)
+    azure_doc_id = Column(String(255), unique=True, index=True)
+    chunk_count = Column(Integer, default=0)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    source_id = Column(Integer, ForeignKey("sources.id"), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="rag_documents")
+
+class ChatMessage(Base):
+    __tablename__ = "chat_messages"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    rag_doc_id = Column(Integer, ForeignKey("rag_documents.id"), nullable=True)
+    role = Column(String(50)) # 'user' or 'assistant'
+    content = Column(UnicodeText, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    owner = relationship("User", back_populates="chat_messages")

models/schemas.py

@@ -0,0 +1,223 @@
+from pydantic import BaseModel, EmailStr
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+
+# User Schemas
+class UserBase(BaseModel):
+    email: EmailStr
+
+class UserCreate(UserBase):
+    password: str
+
+class UserLogin(BaseModel):
+    email: EmailStr
+    password: str
+
+class UserResponse(UserBase):
+    id: int
+    is_active: bool = True
+
+    class Config:
+        from_attributes = True
+
+# Token Schemas
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    email: Optional[str] = None
+
+# Source Schemas
+class SourceFileResponse(BaseModel):
+    id: int
+    filename: str
+    s3_key: str
+    public_url: str
+    private_url: Optional[str] = None
+    size: int
+    created_at: datetime
+    rag_id: Optional[int] = None
+    azure_doc_id: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+
+# Podcast Schemas
+class PodcastAnalyzeRequest(BaseModel):
+    file_key: str
+    duration_minutes: int = 10
+
+class PodcastGenerateRequest(BaseModel):
+    user_prompt: str
+    model: str = "gpt-4o"
+    duration_minutes: int = 10
+    podcast_format: str = "deep dive"
+    pdf_suggestions: str = ""
+    file_key: Optional[str] = None
+    tts_model: str = "gemini-2.5-flash-preview-tts"
+    spk1_voice: str = "Zephyr"
+    spk2_voice: str = "Charon"
+    bgm_choice: str = "No BGM"
+    temperature: float = 1.0
+
+# Flashcard Schemas
+class FlashcardItem(BaseModel):
+    question: str
+    answer: str
+
+class FlashcardGenerateRequest(BaseModel):
+    file_key: Optional[str] = None
+    text_input: Optional[str] = None
+    difficulty: str = "medium"
+    quantity: str = "standard"
+    topic: Optional[str] = None
+    language: str = "English"
+
+class FlashcardResponse(BaseModel):
+    id: int
+    question: str
+    answer: str
+
+class FlashcardSetResponse(BaseModel):
+    id: int
+    title: Optional[str]
+    difficulty: str
+    created_at: datetime
+    flashcards: List[FlashcardResponse]
+
+    class Config:
+        from_attributes = True
+
+# Mind Map Schemas
+class MindMapGenerateRequest(BaseModel):
+    file_key: Optional[str] = None
+    text_input: Optional[str] = None
+    title: Optional[str] = None
+
+class MindMapResponse(BaseModel):
+    title: str
+    mermaid_code: str
+    message: str
+
+# Quiz Schemas
+class QuizGenerateRequest(BaseModel):
+    file_key: Optional[str] = None
+    text_input: Optional[str] = None
+    difficulty: str = "medium"
+    topic: Optional[str] = None
+    language: str = "English"
+    count: str = "STANDARD" # FEWER, STANDARD, MORE
+
+class QuizQuestionResponse(BaseModel):
+    id: int
+    question: str
+    hint: Optional[str]
+    choices: dict
+    answer: str
+    explanation: Optional[str]
+
+class QuizSetResponse(BaseModel):
+    id: int
+    title: Optional[str]
+    difficulty: str
+    created_at: datetime
+    questions: List[QuizQuestionResponse]
+
+    class Config:
+        from_attributes = True
+
+# Report Schemas
+class ReportFormatSuggestion(BaseModel):
+    name: str
+    description: str
+    prompt: str
+
+class ReportFormatSuggestionResponse(BaseModel):
+    suggestions: List[ReportFormatSuggestion]
+
+class ReportGenerateRequest(BaseModel):
+    file_key: Optional[str] = None
+    text_input: Optional[str] = None
+    format_key: str # briefing_doc, study_guide, blog_post, custom, or suggested_X
+    custom_prompt: Optional[str] = None
+    language: str = "Japanese"
+
+class ReportResponse(BaseModel):
+    id: int
+    title: str
+    content: str
+    format_key: str
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+# Video Summary Schemas
+class VideoSummaryGenerateRequest(BaseModel):
+    file_key: str
+    language: str = "Japanese"
+    voice_name: str = "Kore" # Kore, Fenrir, etc.
+    use_slides_transformation: bool = True
+    custom_prompt: Optional[str] = ""
+
+class VideoSummaryResponse(BaseModel):
+    id: int
+    title: str
+    s3_key: str
+    public_url: str
+    private_url: Optional[str] = None
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+# RAG Schemas
+class RAGDocumentUploadRequest(BaseModel):
+    source_id: Optional[int] = None  # Link to existing source file
+
+class RAGSearchRequest(BaseModel):
+    query: str
+    top_k: int = 5
+
+class RAGDocumentResponse(BaseModel):
+    id: int
+    filename: str
+    azure_doc_id: str
+    blob_url: Optional[str]
+    content_preview: Optional[str]
+    chunk_count: int
+    created_at: datetime
+
+    class Config:
+        from_attributes = True
+
+class RAGSearchResult(BaseModel):
+    content: str
+    score: float
+    source: str
+    metadata: Dict[str, Any] = {}
+
+class RAGSearchResponse(BaseModel):
+    results: List[RAGSearchResult]
+    answer: Optional[str] = None 
+# RAG Query Request (Simplified)
+class RAGQueryRequest(BaseModel):
+    file_key: str  # S3 key of the source file
+    query: str
+    top_k: int = 3  # Number of relevant chunks to use
+
+# Chat Schemas
+class ChatMessageCreate(BaseModel):
+    query: str  # The user's question or message
+    rag_doc_id: Optional[int] = None # Optional: Link to a specific document for context
+
+class ChatMessageResponse(BaseModel):
+    id: int
+    role: str
+    content: str # keeping 'content' here as it represents the stored/returned textual data
+    rag_doc_id: Optional[int]
+    created_at: datetime
+
+    class Config:
+        from_attributes = True

requirements.txt

@@ -0,0 +1,27 @@
+fastapi[all]
+uvicorn
+python-multipart
+boto3
+python-jose[cryptography]
+bcrypt
+pydantic-settings
+python-dotenv
+openai
+google-genai
+google-api-python-client
+google-auth
+google-auth-httplib2
+google-auth-oauthlib
+pydub
+ffmpeg-python
+sqlalchemy
+pyodbc
+moviepy
+pdf2image
+Pillow
+azure-search-documents
+azure-storage-blob
+azure-identity
+PyPDF2
+tiktoken
+numpy

services/flashcard_service.py

@@ -0,0 +1,164 @@
+import json
+import logging
+import os
+import tempfile
+from typing import List, Dict, Optional, Any
+import openai
+from botocore.exceptions import ClientError
+
+from core.config import settings
+from core.prompts import get_flashcard_system_prompt, get_flashcard_topic_prompt, get_flashcard_explanation_prompt
+from services.s3_service import s3_service
+
+logger = logging.getLogger(__name__)
+
+class FlashcardService:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+
+    async def generate_flashcards(
+        self,
+        file_key: Optional[str] = None,
+        text_input: Optional[str] = None,
+        difficulty: str = "medium",
+        quantity: str = "standard",
+        topic: Optional[str] = None,
+        language: str = "English"
+    ) -> List[Dict[str, str]]:
+        """
+        Generates flashcards from either an S3 PDF or direct text input.
+        """
+        try:
+            system_prompt = get_flashcard_system_prompt(difficulty, quantity, language)
+            if topic:
+                system_prompt += get_flashcard_topic_prompt(topic)
+
+            content_to_analyze = ""
+            
+            if file_key:
+                # Download PDF from S3
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+                tmp_path = tmp.name
+                tmp.close() # Close handle so other processes can access on Windows
+
+                try:
+                    s3_service.s3_client.download_file(
+                        settings.AWS_S3_BUCKET,
+                        file_key,
+                        tmp_path
+                    )
+                    
+                    with open(tmp_path, "rb") as f:
+                        uploaded_file = self.openai_client.files.create(
+                            file=f,
+                            purpose="assistants"
+                        )
+                    
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "file",
+                                    "file": {"file_id": uploaded_file.id}
+                                }
+                            ]
+                        }
+                    ]
+                    
+                    response = self.openai_client.chat.completions.create(
+                        model="gpt-4o-mini", # Using 4o-mini for efficiency
+                        messages=messages,
+                        temperature=0.7
+                    )
+                    
+                    # Clean up OpenAI file
+                    self.openai_client.files.delete(uploaded_file.id)
+                    
+                    raw_content = response.choices[0].message.content
+                    
+                finally:
+                    if os.path.exists(tmp_path):
+                        os.remove(tmp_path)
+            
+            elif text_input:
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": text_input}
+                ]
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages,
+                    temperature=0.7
+                )
+                raw_content = response.choices[0].message.content
+            
+            else:
+                raise ValueError("Either file_key or text_input must be provided")
+
+            # Parse JSON
+            # Remove markdown code blocks if present
+            if "```json" in raw_content:
+                raw_content = raw_content.split("```json")[1].split("```")[0].strip()
+            elif "```" in raw_content:
+                raw_content = raw_content.split("```")[1].split("```")[0].strip()
+            
+            flashcards = json.loads(raw_content)
+            return flashcards
+
+        except Exception as e:
+            logger.error(f"Flashcard generation failed: {e}")
+            raise
+
+    async def generate_explanation(self, question: str, file_key: Optional[str] = None, language: str = "English") -> str:
+        """
+        Generates a detailed explanation for a flashcard question.
+        """
+        try:
+            explanation_prompt = get_flashcard_explanation_prompt(question, language)
+            
+            if file_key:
+                # Similar logic to generation if PDF context is needed
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+                tmp_path = tmp.name
+                tmp.close()
+
+                try:
+                    s3_service.s3_client.download_file(
+                        settings.AWS_S3_BUCKET,
+                        file_key,
+                        tmp_path
+                    )
+                    with open(tmp_path, "rb") as f:
+                        uploaded_file = self.openai_client.files.create(file=f, purpose="assistants")
+                    
+                    messages = [
+                        {"role": "system", "content": explanation_prompt},
+                        {"role": "user", "content": [{"type": "file", "file": {"file_id": uploaded_file.id}}]}
+                    ]
+                    response = self.openai_client.chat.completions.create(
+                        model="gpt-4o-mini",
+                        messages=messages
+                    )
+                    self.openai_client.files.delete(uploaded_file.id)
+                    return response.choices[0].message.content
+                finally:
+                    if os.path.exists(tmp_path):
+                        os.remove(tmp_path)
+            else:
+                messages = [
+                    {"role": "system", "content": explanation_prompt},
+                    {"role": "user", "content": f"Please explain the question: {question}"}
+                ]
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages
+                )
+                return response.choices[0].message.content
+
+        except Exception as e:
+            logger.error(f"Explanation generation failed: {e}")
+            raise
+
+flashcard_service = FlashcardService()

services/mindmap_service.py

@@ -0,0 +1,107 @@
+import logging
+import os
+import tempfile
+from typing import Optional
+import openai
+from core.config import settings
+from core.prompts import get_mindmap_system_prompt
+from services.s3_service import s3_service
+
+logger = logging.getLogger(__name__)
+
+class MindMapService:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+
+    async def generate_mindmap(
+        self,
+        file_key: Optional[str] = None,
+        text_input: Optional[str] = None
+    ) -> str:
+        """
+        Generates a Mermaid mindmap from either an S3 PDF or direct text input.
+        """
+        try:
+            system_prompt = get_mindmap_system_prompt()
+
+            if file_key:
+                # Download PDF from S3
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+                tmp_path = tmp.name
+                tmp.close()
+
+                try:
+                    s3_service.s3_client.download_file(
+                        settings.AWS_S3_BUCKET,
+                        file_key,
+                        tmp_path
+                    )
+                    
+                    with open(tmp_path, "rb") as f:
+                        uploaded_file = self.openai_client.files.create(
+                            file=f,
+                            purpose="assistants"
+                        )
+                    
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "file",
+                                    "file": {"file_id": uploaded_file.id}
+                                }
+                            ]
+                        }
+                    ]
+                    
+                    response = self.openai_client.chat.completions.create(
+                        model="gpt-4o-mini",
+                        messages=messages,
+                        temperature=0.7
+                    )
+                    
+                    # Clean up OpenAI file
+                    self.openai_client.files.delete(uploaded_file.id)
+                    
+                    raw_content = response.choices[0].message.content
+                    
+                finally:
+                    if os.path.exists(tmp_path):
+                        os.remove(tmp_path)
+            
+            elif text_input:
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": text_input}
+                ]
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages,
+                    temperature=0.7
+                )
+                raw_content = response.choices[0].message.content
+            
+            else:
+                raise ValueError("Either file_key or text_input must be provided")
+
+            # Clean up the output
+            if "```mermaid" in raw_content:
+                raw_content = raw_content.split("```mermaid")[1].split("```")[0].strip()
+            elif "```" in raw_content:
+                raw_content = raw_content.split("```")[1].split("```")[0].strip()
+            
+            # Ensure it starts with 'mindmap'
+            if "mindmap" not in raw_content.lower():
+                # If the AI missed the header, we might need to handle it, 
+                # but usually the prompt is strong.
+                pass
+
+            return raw_content.strip()
+
+        except Exception as e:
+            logger.error(f"Mind map generation failed: {e}")
+            raise
+
+mindmap_service = MindMapService()

services/podcast_service.py

@@ -0,0 +1,249 @@
+import re
+import os
+import json
+import time
+import struct
+import logging
+import mimetypes
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Tuple, Optional, Dict
+
+import openai
+from google import genai
+from google.genai import types
+from pydantic import BaseModel
+from pydub import AudioSegment
+
+from core.config import settings
+from core.prompts import SYSTEM_PROMPT, ANALYSIS_PROMPT
+from services.s3_service import s3_service
+from core import constants
+
+logger = logging.getLogger(__name__)
+
+class AnalysisOutput(BaseModel):
+    program_structure: str
+    script: str
+
+class MultiProposalOutput(BaseModel):
+    proposals: List[AnalysisOutput]
+
+# Automatically generate voice choices from constants
+VOICE_CHOICES = {v["value"]: v["value"] for v in constants.PODCAST_VOICES}
+
+BGM_CHOICES = {
+    "No BGM": None,
+    "BGM 1": "assets/bgm/BGM_1.mp3",
+    "BGM 2": "assets/bgm/BGM_2.mp3", 
+    "BGM 3": "assets/bgm/BGM_3.mp3"
+}
+
+class PodcastService:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+        self.genai_client = genai.Client(api_key=settings.GEMINI_API_KEY)
+
+    def compute_script_targets(self, duration_minutes: int) -> int:
+        if duration_minutes <= 5: return 2000
+        elif duration_minutes <= 10: return 3000
+        elif duration_minutes <= 15: return 4000
+        else: return 5000
+
+    async def analyze_pdf(self, file_key: str, duration_minutes: int, model: str = "gpt-4o"):
+        # 1. Get file from S3
+        # Since openai files.create needs a file, we download it temporarily
+        temp_path = f"temp_{int(time.time())}.pdf"
+        try:
+            import boto3
+            s3 = boto3.client('s3', 
+                              aws_access_key_id=settings.AWS_ACCESS_KEY_ID, 
+                              aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+                              region_name=settings.AWS_REGION)
+            s3.download_file(settings.AWS_S3_BUCKET, file_key, temp_path)
+
+            # 2. Upload to OpenAI
+            with open(temp_path, "rb") as f:
+                file_response = self.openai_client.files.create(file=f, purpose="assistants")
+            
+            # 3. Analyze
+            formatted_prompt = ANALYSIS_PROMPT.format(duration_minutes=duration_minutes)
+            
+            response = self.openai_client.chat.completions.parse(
+                model=model,
+                messages=[
+                    {"role": "system", "content": formatted_prompt},
+                    {"role": "user", "content": [{"type": "file", "file": {"file_id": file_response.id}}]}
+                ],
+                temperature=1.0,
+                response_format=MultiProposalOutput
+            )
+            return response.choices[0].message.content
+        finally:
+            if os.path.exists(temp_path):
+                os.remove(temp_path)
+
+    async def generate_script(self, user_prompt: str, model: str, duration_minutes: int, 
+                             podcast_format: str, pdf_suggestions: str, file_key: Optional[str] = None):
+        target_words = self.compute_script_targets(duration_minutes)
+        formatted_system = SYSTEM_PROMPT.format(
+            target_words=target_words,
+            podcast_format=podcast_format,
+            pdf_suggestions=pdf_suggestions
+        )
+
+        messages = [{"role": "system", "content": formatted_system}]
+        
+        temp_path = None
+        if file_key:
+            temp_path = f"temp_gen_{int(time.time())}.pdf"
+            import boto3
+            s3 = boto3.client('s3', 
+                              aws_access_key_id=settings.AWS_ACCESS_KEY_ID, 
+                              aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+                              region_name=settings.AWS_REGION)
+            s3.download_file(settings.AWS_S3_BUCKET, file_key, temp_path)
+            
+            with open(temp_path, "rb") as f:
+                file_response = self.openai_client.files.create(file=f, purpose="assistants")
+            
+            messages.append({
+                "role": "user", 
+                "content": [
+                    {"type": "file", "file": {"file_id": file_response.id}},
+                    {"type": "text", "text": user_prompt}
+                ]
+            })
+        else:
+            messages.append({"role": "user", "content": user_prompt})
+
+        try:
+            response = self.openai_client.chat.completions.create(
+                model=model,
+                messages=messages,
+                temperature=1.0,
+                max_completion_tokens=100000
+            )
+            return response.choices[0].message.content
+        finally:
+            if temp_path and os.path.exists(temp_path):
+                os.remove(temp_path)
+
+    def parse_script(self, script: str) -> List[Tuple[str, str]]:
+        dialogs = []
+        pattern = re.compile(r"^(Speaker [12])[::]\s*(.*)$", re.MULTILINE)
+        for match in pattern.finditer(script):
+            speaker, text = match.groups()
+            dialogs.append((speaker, text))
+        return dialogs
+
+    def split_script(self, dialogs: List[Tuple[str, str]], chunk_size=20) -> List[str]:
+        chunks = []
+        for i in range(0, len(dialogs), chunk_size):
+            chunk = dialogs[i:i + chunk_size]
+            chunks.append("\n".join([f"{s}: {t}" for s, t in chunk]))
+        return chunks
+
+    def generate_audio_chunk(self, chunk_script: str, tts_model: str, spk1_voice: str, 
+                           spk2_voice: str, temperature: float, index: int) -> Optional[str]:
+        try:
+            contents = [types.Content(role="user", parts=[types.Part.from_text(text=chunk_script)])]
+            config = types.GenerateContentConfig(
+                temperature=temperature,
+                response_modalities=["audio"],
+                speech_config=types.SpeechConfig(
+                    multi_speaker_voice_config=types.MultiSpeakerVoiceConfig(
+                        speaker_voice_configs=[
+                            types.SpeakerVoiceConfig(speaker="Speaker 1", voice_config=types.VoiceConfig(
+                                prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=spk1_voice))),
+                            types.SpeakerVoiceConfig(speaker="Speaker 2", voice_config=types.VoiceConfig(
+                                prebuilt_voice_config=types.PrebuiltVoiceConfig(voice_name=spk2_voice)))
+                        ]
+                    )
+                )
+            )
+            
+            audio_data = None
+            mime_type = "audio/wav"
+            for chunk in self.genai_client.models.generate_content_stream(model=tts_model, contents=contents, config=config):
+                if chunk.candidates and chunk.candidates[0].content.parts:
+                    part = chunk.candidates[0].content.parts[0]
+                    if part.inline_data:
+                        audio_data = part.inline_data.data
+                        mime_type = part.inline_data.mime_type
+                        break
+            
+            if audio_data:
+                # Basic WAV conversion if needed (simplified from original)
+                if "wav" not in mime_type.lower():
+                    # We usually get raw PCM or similar, need header
+                    audio_data = self._convert_to_wav(audio_data, mime_type)
+                
+                path = f"chunk_{index}_{int(time.time())}.wav"
+                with open(path, "wb") as f:
+                    f.write(audio_data)
+                return path
+        except Exception as e:
+            logger.error(f"Error generating chunk {index}: {e}")
+        return None
+
+    def _convert_to_wav(self, audio_data: bytes, mime_type: str) -> bytes:
+        # Simplified conversion
+        rate = 24000
+        if "rate=" in mime_type:
+            try: rate = int(mime_type.split("rate=")[1].split(";")[0])
+            except: pass
+        
+        bits = 16
+        num_channels = 1
+        data_size = len(audio_data)
+        header = struct.pack("<4sI4s4sIHHIIHH4sI", b"RIFF", 36 + data_size, b"WAVE", b"fmt ", 16, 1, num_channels, rate, rate * num_channels * (bits // 8), num_channels * (bits // 8), bits, b"data", data_size)
+        return header + audio_data
+
+    async def generate_full_audio(self, script: str, tts_model: str, spk1_voice: str, 
+                                spk2_voice: str, temperature: float, bgm_choice: str):
+        dialogs = self.parse_script(script)
+        chunks = self.split_script(dialogs)
+        
+        chunk_paths = [None] * len(chunks)
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = {executor.submit(self.generate_audio_chunk, chunks[i], tts_model, spk1_voice, spk2_voice, temperature, i): i for i in range(len(chunks))}
+            for future in as_completed(futures):
+                idx = futures[future]
+                chunk_paths[idx] = future.result()
+        
+        valid_paths = [p for p in chunk_paths if p]
+        if not valid_paths: return None
+        
+        # Combine
+        combined = AudioSegment.empty()
+        for p in valid_paths:
+            combined += AudioSegment.from_file(p)
+            combined += AudioSegment.silent(duration=500)
+            os.remove(p)
+        
+        final_path = f"final_podcast_{int(time.time())}.wav"
+        
+        # Mix BGM
+        bgm_path = BGM_CHOICES.get(bgm_choice)
+        if bgm_path and os.path.exists(bgm_path):
+            bgm = AudioSegment.from_file(bgm_path)
+            # Simple mix: loop BGM, fade in/out
+            if len(bgm) < len(combined) + 10000:
+                bgm = bgm * ( (len(combined) + 10000) // len(bgm) + 1 )
+            
+            bgm = bgm[:len(combined) + 10000]
+            bgm_main = bgm[5000:5000+len(combined)] - 16
+            bgm_intro = bgm[:5000]
+            bgm_outro = bgm[5000+len(combined):].fade_out(5000) - 16
+            
+            bgm_processed = bgm_intro + bgm_main + bgm_outro
+            combined_with_intro = AudioSegment.silent(duration=5000) + combined + AudioSegment.silent(duration=5000)
+            final_audio = combined_with_intro.overlay(bgm_processed)
+            final_audio.export(final_path, format="wav")
+        else:
+            combined.export(final_path, format="wav")
+            
+        return final_path
+
+podcast_service = PodcastService()

services/quiz_service.py

@@ -0,0 +1,121 @@
+import json
+import logging
+import os
+import tempfile
+from typing import List, Dict, Optional, Any
+import openai
+
+from core.config import settings
+from core.prompts import get_quiz_system_prompt
+from services.s3_service import s3_service
+
+logger = logging.getLogger(__name__)
+
+class QuizService:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+
+    async def generate_quiz(
+        self,
+        file_key: Optional[str] = None,
+        text_input: Optional[str] = None,
+        difficulty: str = "medium",
+        topic: Optional[str] = None,
+        language: str = "English",
+        count_mode: str = "STANDARD"
+    ) -> List[Dict[str, Any]]:
+        """
+        Generates a quiz from either an S3 PDF or direct text input.
+        """
+        try:
+            # Map count mode to actual numbers
+            counts = {
+                "FEWER": "5-10",
+                "STANDARD": "10-15",
+                "MORE": "20-25"
+            }
+            num_range = counts.get(count_mode, "10-15")
+            
+            system_prompt = get_quiz_system_prompt(language).replace("{NUM_QUESTIONS}", num_range)
+
+            if file_key:
+                # Download PDF from S3
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+                tmp_path = tmp.name
+                tmp.close()
+
+                try:
+                    s3_service.s3_client.download_file(
+                        settings.AWS_S3_BUCKET,
+                        file_key,
+                        tmp_path
+                    )
+                    
+                    with open(tmp_path, "rb") as f:
+                        uploaded_file = self.openai_client.files.create(
+                            file=f,
+                            purpose="assistants"
+                        )
+                    
+                    user_message = f"Analyze the PDF and create {num_range} questions. Difficulty: {difficulty}."
+                    if topic:
+                        user_message += f" Topic: {topic}."
+
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {
+                            "role": "user",
+                            "content": [
+                                {"type": "text", "text": user_message},
+                                {
+                                    "type": "file",
+                                    "file": {"file_id": uploaded_file.id}
+                                }
+                            ]
+                        }
+                    ]
+                    
+                    response = self.openai_client.chat.completions.create(
+                        model="gpt-4o-mini",
+                        messages=messages,
+                        response_format={"type": "json_object"},
+                        temperature=0.7
+                    )
+                    
+                    self.openai_client.files.delete(uploaded_file.id)
+                    raw_content = response.choices[0].message.content
+                    
+                finally:
+                    if os.path.exists(tmp_path):
+                        os.remove(tmp_path)
+            
+            elif text_input:
+                user_message = f"Analyze the text and create {num_range} questions. Difficulty: {difficulty}."
+                if topic:
+                    user_message += f" Topic: {topic}."
+                user_message += f"\n\nText content:\n{text_input}"
+
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_message}
+                ]
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages,
+                    response_format={"type": "json_object"},
+                    temperature=0.7
+                )
+                raw_content = response.choices[0].message.content
+            
+            else:
+                raise ValueError("Either file_key or text_input must be provided")
+
+            data = json.loads(raw_content)
+            # The prompt asks for {"quizzes": [...]}
+            return data.get("quizzes", [])
+
+        except Exception as e:
+            logger.error(f"Quiz generation failed: {e}")
+            raise
+
+quiz_service = QuizService()

services/rag_service.py

@@ -0,0 +1,243 @@
+import os
+import logging
+import uuid
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+
+from azure.search.documents import SearchClient
+from azure.search.documents.indexes import SearchIndexClient
+from azure.search.documents.indexes.models import (
+    SearchIndex,
+    SimpleField,
+    SearchableField,
+    SearchField,
+    VectorSearch,
+    HnswAlgorithmConfiguration,
+    VectorSearchProfile,
+    SearchFieldDataType
+)
+from azure.core.credentials import AzureKeyCredential
+from openai import AzureOpenAI
+
+from core.config import settings
+
+logger = logging.getLogger(__name__)
+
+class RAGService:
+    def __init__(self):
+        # Azure Search
+        self.search_endpoint = settings.AZURE_SEARCH_ENDPOINT
+        self.search_key = settings.AZURE_SEARCH_KEY
+        self.index_name = settings.AZURE_SEARCH_INDEX_NAME
+        
+        # Azure OpenAI for embeddings
+        self.azure_openai_client = AzureOpenAI(
+            api_key=settings.AZURE_OPENAI_API_KEY,
+            api_version=settings.AZURE_OPENAI_API_VERSION,
+            azure_endpoint=settings.AZURE_OPENAI_ENDPOINT.split("/openai/")[0]
+        )
+        self.embedding_deployment = settings.AZURE_OPENAI_DEPLOYMENT_NAME
+        
+        # Initialize clients
+        self.search_client = SearchClient(
+            endpoint=self.search_endpoint,
+            index_name=self.index_name,
+            credential=AzureKeyCredential(self.search_key)
+        )
+        
+        self.index_client = SearchIndexClient(
+            endpoint=self.search_endpoint,
+            credential=AzureKeyCredential(self.search_key)
+        )
+        
+        # Ensure index exists
+        self._ensure_index_exists()
+
+    def _ensure_index_exists(self):
+        """Create or recreate Azure AI Search index if it doesn't exist or is incompatible."""
+        try:
+            existing_index = self.index_client.get_index(self.index_name)
+            
+            # Check for required fields
+            required_fields = {"filename", "doc_id", "user_id", "content_vector"}
+            existing_fields = {field.name for field in existing_index.fields}
+            
+            if not required_fields.issubset(existing_fields):
+                logger.warning(f"Index {self.index_name} is incompatible. Recreating...")
+                self.index_client.delete_index(self.index_name)
+                self._create_index()
+            else:
+                logger.info(f"Index {self.index_name} exists and is compatible")
+        except Exception:
+            logger.info(f"Creating index {self.index_name}...")
+            self._create_index()
+
+    def _create_index(self):
+        """Create the search index with vector configuration."""
+        fields = [
+            SimpleField(name="id", type=SearchFieldDataType.String, key=True),
+            SearchableField(name="content", type=SearchFieldDataType.String),
+            SearchableField(name="filename", type=SearchFieldDataType.String, filterable=True),
+            SimpleField(name="doc_id", type=SearchFieldDataType.String, filterable=True),
+            SimpleField(name="user_id", type=SearchFieldDataType.String, filterable=True),
+            SimpleField(name="chunk_index", type=SearchFieldDataType.Int32),
+            SimpleField(name="created_at", type=SearchFieldDataType.DateTimeOffset),
+            SearchField(
+                name="content_vector",
+                type=SearchFieldDataType.Collection(SearchFieldDataType.Single),
+                searchable=True,
+                vector_search_dimensions=1536,
+                vector_search_profile_name="my-vector-profile"
+            )
+        ]
+
+        vector_search = VectorSearch(
+            algorithms=[HnswAlgorithmConfiguration(name="my-hnsw")],
+            profiles=[
+                VectorSearchProfile(
+                    name="my-vector-profile",
+                    algorithm_configuration_name="my-hnsw"
+                )
+            ]
+        )
+
+        index = SearchIndex(
+            name=self.index_name,
+            fields=fields,
+            vector_search=vector_search
+        )
+
+        self.index_client.create_index(index)
+        logger.info(f"Created index: {self.index_name}")
+
+    def generate_embeddings(self, texts: List[str]) -> List[List[float]]:
+        """Generate embeddings using Azure OpenAI."""
+        try:
+            embeddings = []
+            for text in texts:
+                response = self.azure_openai_client.embeddings.create(
+                    input=text,
+                    model=self.embedding_deployment
+                )
+                embeddings.append(response.data[0].embedding)
+            return embeddings
+        except Exception as e:
+            logger.error(f"Error generating embeddings: {e}")
+            raise
+
+    def index_document(
+        self, 
+        chunks: List[str], 
+        filename: str, 
+        user_id: int,
+        doc_id: str
+    ) -> int:
+        """Index document chunks with embeddings in Azure Search."""
+        try:
+            # Generate embeddings
+            logger.info(f"Generating embeddings for {len(chunks)} chunks...")
+            embeddings = self.generate_embeddings(chunks)
+            
+            # Prepare documents
+            documents = []
+            for idx, (chunk, embedding) in enumerate(zip(chunks, embeddings)):
+                doc = {
+                    "id": f"{doc_id}_{idx}",
+                    "content": chunk,
+                    "filename": filename,
+                    "doc_id": doc_id,
+                    "user_id": str(user_id),
+                    "chunk_index": idx,
+                    "created_at": datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ"),
+                    "content_vector": embedding
+                }
+                documents.append(doc)
+            
+            # Upload to search index
+            result = self.search_client.upload_documents(documents=documents)
+            logger.info(f"Indexed {len(documents)} chunks for {filename}")
+            
+            return len(documents)
+            
+        except Exception as e:
+            logger.error(f"Error indexing document: {e}")
+            raise
+
+    def search_document(
+        self, 
+        query: str, 
+        doc_id: str,
+        user_id: int,
+        top_k: int = 3
+    ) -> List[Dict[str, Any]]:
+        """Search within a specific document using vector search."""
+        try:
+            # Generate query embedding
+            query_embedding = self.generate_embeddings([query])[0]
+            
+            # Vector search with filters
+            from azure.search.documents.models import VectorizedQuery
+            
+            vector_query = VectorizedQuery(
+                vector=query_embedding,
+                k_nearest_neighbors=top_k,
+                fields="content_vector"
+            )
+            
+            results = self.search_client.search(
+                search_text=None,
+                vector_queries=[vector_query],
+                filter=f"doc_id eq '{doc_id}' and user_id eq '{user_id}'",
+                top=top_k,
+                select=["content", "filename", "chunk_index"]
+            )
+            
+            # Format results
+            search_results = []
+            for result in results:
+                search_results.append({
+                    "content": result["content"],
+                    "chunk_index": result.get("chunk_index", 0)
+                })
+            
+            return search_results
+            
+        except Exception as e:
+            logger.error(f"Error searching document: {e}")
+            raise
+
+    def delete_document(self, doc_id: str):
+        """Delete all chunks of a document from the search index."""
+        try:
+            # Search for all chunks
+            results = self.search_client.search(
+                search_text="*",
+                filter=f"doc_id eq '{doc_id}'",
+                select=["id"],
+                top=1000
+            )
+            
+            # Delete all chunks
+            doc_ids = [{"id": r["id"]} for r in results]
+            if doc_ids:
+                self.search_client.delete_documents(documents=doc_ids)
+                logger.info(f"Deleted {len(doc_ids)} chunks for document {doc_id}")
+                
+        except Exception as e:
+            logger.error(f"Error deleting document: {e}")
+            raise
+
+    def document_exists(self, doc_id: str, user_id: int) -> bool:
+        """Check if a document is already indexed."""
+        try:
+            results = self.search_client.search(
+                search_text="*",
+                filter=f"doc_id eq '{doc_id}' and user_id eq '{user_id}'",
+                top=1,
+                select=["id"]
+            )
+            return len(list(results)) > 0
+        except:
+            return False
+
+rag_service = RAGService()

services/report_service.py

@@ -0,0 +1,191 @@
+import json
+import logging
+import os
+import tempfile
+from typing import List, Dict, Optional, Any
+import openai
+
+from core.config import settings
+from core.prompts import get_report_prompt, get_report_suggestion_prompt
+from services.s3_service import s3_service
+
+logger = logging.getLogger(__name__)
+
+class ReportService:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+
+    async def generate_format_suggestions(
+        self,
+        file_key: Optional[str] = None,
+        text_input: Optional[str] = None,
+        language: str = "Japanese"
+    ) -> List[Dict[str, str]]:
+        """
+        Generates 4 AI-suggested report formats based on the content.
+        """
+        try:
+            system_prompt = get_report_suggestion_prompt(language)
+
+            if file_key:
+                # Download PDF from S3
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+                tmp_path = tmp.name
+                tmp.close()
+
+                try:
+                    s3_service.s3_client.download_file(
+                        settings.AWS_S3_BUCKET,
+                        file_key,
+                        tmp_path
+                    )
+                    
+                    with open(tmp_path, "rb") as f:
+                        uploaded_file = self.openai_client.files.create(
+                            file=f,
+                            purpose="assistants"
+                        )
+                    
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "file",
+                                    "file": {"file_id": uploaded_file.id}
+                                }
+                            ]
+                        }
+                    ]
+                    
+                    response = self.openai_client.chat.completions.create(
+                        model="gpt-4o-mini",
+                        messages=messages,
+                        response_format={"type": "json_object"},
+                        temperature=0.7
+                    )
+                    
+                    self.openai_client.files.delete(uploaded_file.id)
+                    raw_content = response.choices[0].message.content
+                    
+                finally:
+                    if os.path.exists(tmp_path):
+                        os.remove(tmp_path)
+            
+            elif text_input:
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Analyze this content:\n\n{text_input}"}
+                ]
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages,
+                    response_format={"type": "json_object"},
+                    temperature=0.7
+                )
+                raw_content = response.choices[0].message.content
+            
+            else:
+                raise ValueError("Either file_key or text_input must be provided")
+
+            data = json.loads(raw_content)
+            return data.get("suggestions", [])
+
+        except Exception as e:
+            logger.error(f"Format suggestion failed: {e}")
+            return []
+
+    async def generate_report(
+        self,
+        file_key: Optional[str] = None,
+        text_input: Optional[str] = None,
+        format_key: str = "briefing_doc",
+        custom_prompt: Optional[str] = None,
+        language: str = "Japanese"
+    ) -> str:
+        """
+        Generates a full report based on the selected format.
+        """
+        try:
+            base_prompt = get_report_prompt(format_key, custom_prompt or "", language)
+            
+            # Language styling instruction
+            if language == "Japanese":
+                system_prompt = (
+                    "あなたは日本語でレポートを作成するAIアシスタントです。すべての回答は日本語で書いてください。\n\n"
+                    f"{base_prompt}\n\n"
+                    "重要: レポート全体を日本語で書いてください。回答はマークダウン形式で、適切な見出し、箇条書き、構造を使用して読みやすくフォーマットしてください。"
+                )
+            else:
+                system_prompt = (
+                    "You are an AI assistant that creates reports in English. Write all responses in English.\n\n"
+                    f"{base_prompt}\n\n"
+                    "IMPORTANT: Write the entire report in English. Please format your response in markdown with proper headings, bullet points, and structure for easy reading."
+                )
+
+            if file_key:
+                # Download PDF from S3
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".pdf")
+                tmp_path = tmp.name
+                tmp.close()
+
+                try:
+                    s3_service.s3_client.download_file(
+                        settings.AWS_S3_BUCKET,
+                        file_key,
+                        tmp_path
+                    )
+                    
+                    with open(tmp_path, "rb") as f:
+                        uploaded_file = self.openai_client.files.create(
+                            file=f,
+                            purpose="assistants"
+                        )
+                    
+                    messages = [
+                        {"role": "system", "content": system_prompt},
+                        {
+                            "role": "user",
+                            "content": [
+                                {
+                                    "type": "file",
+                                    "file": {"file_id": uploaded_file.id}
+                                }
+                            ]
+                        }
+                    ]
+                    
+                    response = self.openai_client.chat.completions.create(
+                        model="gpt-4o-mini",
+                        messages=messages,
+                        temperature=0.7
+                    )
+                    
+                    self.openai_client.files.delete(uploaded_file.id)
+                    return response.choices[0].message.content
+                    
+                finally:
+                    if os.path.exists(tmp_path):
+                        os.remove(tmp_path)
+            
+            elif text_input:
+                messages = [
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Please analyze the following content and generate a report based on it:\n\n{text_input}"}
+                ]
+                response = self.openai_client.chat.completions.create(
+                    model="gpt-4o-mini",
+                    messages=messages,
+                    temperature=0.7
+                )
+                return response.choices[0].message.content
+            
+            else:
+                raise ValueError("Either file_key or text_input must be provided")
+
+        except Exception as e:
+            logger.error(f"Report generation failed: {e}")
+            raise
+
+report_service = ReportService()

services/s3_service.py

@@ -0,0 +1,103 @@
+import boto3
+from botocore.exceptions import ClientError
+from core.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+class S3Service:
+    def __init__(self):
+        self.s3_client = boto3.client(
+            's3',
+            aws_access_key_id=settings.AWS_ACCESS_KEY_ID,
+            aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY,
+            region_name=settings.AWS_REGION
+        )
+        self.bucket_name = settings.AWS_S3_BUCKET
+
+    def get_public_url(self, key: str):
+        """
+        Generates the standard S3 public URL for a given key.
+        """
+        return f"https://{self.bucket_name}.s3.{settings.AWS_REGION}.amazonaws.com/{key}"
+
+    def get_presigned_url(self, key: str, expires_in: int = 3600):
+        """
+        Generates a pre-signed URL for secure access. Default: 1 hour.
+        """
+        try:
+            url = self.s3_client.generate_presigned_url(
+                'get_object',
+                Params={'Bucket': self.bucket_name, 'Key': key},
+                ExpiresIn=expires_in
+            )
+            return url
+        except ClientError as e:
+            logger.error(f"Failed to generate presigned URL: {e}")
+            return None
+
+    async def upload_file(self, file_content: bytes, filename: str, user_id: str):
+        """
+        Uploads a file to S3 under a user-specific folder.
+        """
+        key = f"users/{user_id}/sources/{filename}"
+        try:
+            self.s3_client.put_object(
+                Bucket=self.bucket_name,
+                Key=key,
+                Body=file_content
+            )
+            return {
+                "key": key,
+                "public_url": self.get_public_url(key),
+                "private_url": self.get_presigned_url(key)
+            }
+        except ClientError as e:
+            logger.error(f"Failed to upload to S3: {e}")
+            raise Exception("S3 Upload Failed")
+
+    async def list_user_files(self, user_id: str):
+        """
+        Lists files for a specific user.
+        """
+        prefix = f"users/{user_id}/sources/"
+        try:
+            response = self.s3_client.list_objects_v2(
+                Bucket=self.bucket_name,
+                Prefix=prefix
+            )
+            files = []
+            if 'Contents' in response:
+                for obj in response['Contents']:
+                    # Remove the prefix from the filename for display
+                    filename = obj['Key'].replace(prefix, "")
+                    if filename: # Avoid empty strings if the prefix itself is returned
+                        files.append({
+                            "filename": filename,
+                            "key": obj['Key'],
+                            "public_url": self.get_public_url(obj['Key']),
+                            "private_url": self.get_presigned_url(obj['Key']),
+                            "size": obj['Size'],
+                            "last_modified": obj['LastModified']
+                        })
+            return files
+        except ClientError as e:
+            logger.error(f"Failed to list S3 files: {e}")
+            raise Exception("S3 List Failed")
+
+    async def delete_file(self, key: str):
+        """
+        Deletes a file from S3.
+        """
+        try:
+            self.s3_client.delete_object(
+                Bucket=self.bucket_name,
+                Key=key
+            )
+            logger.info(f"Deleted S3 object: {key}")
+            return True
+        except ClientError as e:
+            logger.error(f"Failed to delete S3 object: {e}")
+            return False
+
+s3_service = S3Service()

services/slides_video_service.py

@@ -0,0 +1,463 @@
+import json
+from typing import Dict, List, Optional, Any, Tuple
+import logging
+import os
+import tempfile
+import time
+import shutil
+import io
+import re
+import wave
+import yaml
+import requests
+import openai
+from google.cloud import storage
+from googleapiclient.discovery import build
+from googleapiclient.http import MediaIoBaseUpload
+from google.oauth2 import service_account
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google import genai
+from google.genai import types
+from PIL import Image
+from pdf2image import convert_from_path
+from moviepy import ImageClip, AudioFileClip, VideoFileClip, concatenate_videoclips
+
+from core.config import settings
+from core.prompts import (
+    get_video_script_prompt, 
+    get_pdf_text_extraction_prompt, 
+    get_outline_prompt
+)
+from services.s3_service import s3_service
+
+logger = logging.getLogger(__name__)
+
+# Constants from temp project
+TEMPLATE_HINT: Dict[str, str] = {
+    "cover": "COVER.MAIN",
+    "hook": "HOOK.MAIN",
+    "section": "SECTION.MAIN",
+    "define": "DEFINE.MAIN",
+    "key": "KEY.MAIN",
+    "statement": "STATEMENT.MAIN",
+    "steps": "STEPS.TITLE",
+    "bullets": "BULLETS.TITLE",
+    "quote": "QUOTE.MAIN",
+    "logo": "LOGO.MAIN",
+}
+
+class SlidesVideoService:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+        
+        # Match Temp project: Use API Key for Gemini TTS
+        logger.info("Initializing Gemini Client with API Key for Slides (as in Temp project)")
+        self.gemini_client = genai.Client(api_key=settings.GEMINI_API_KEY)
+
+        self.scopes = [
+            "https://www.googleapis.com/auth/drive",
+            "https://www.googleapis.com/auth/presentations"
+        ]
+
+    def _get_sa_info(self) -> Optional[Dict[str, Any]]:
+        """Parse GCP_SA_JSON - matches original Temp project logic exactly."""
+        sa_json = os.environ.get("GCP_SA_JSON") or os.environ.get("GCS_SA_JSON")
+        if not sa_json:
+            return None
+        # Just parse it directly like the original
+        return json.loads(sa_json)
+
+    def _get_google_creds(self):
+        """
+        Builds Google credentials from environment variables.
+        Matches Temp project logic.
+        """
+        token_json = settings.GOOGLE_OAUTH_TOKEN_JSON
+        if token_json:
+            creds = Credentials.from_authorized_user_info(json.loads(token_json), self.scopes)
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            return creds
+
+        info = self._get_sa_info()
+        if info:
+            return service_account.Credentials.from_service_account_info(info, scopes=self.scopes)
+        
+        raise RuntimeError("Google API credentials not configured (GOOGLE_OAUTH_TOKEN_JSON or GCP_SA_JSON required)")
+
+    def _get_clients(self):
+        creds = self._get_google_creds()
+        slides = build("slides", "v1", credentials=creds)
+        drive = build("drive", "v3", credentials=creds)
+        return slides, drive
+
+    async def extract_text_from_pdf(self, pdf_path: str) -> str:
+        """Extract text from PDF using OpenAI."""
+        with open(pdf_path, "rb") as f:
+            openai_file = self.openai_client.files.create(file=f, purpose="assistants")
+        
+        prompt = get_pdf_text_extraction_prompt()
+        response = self.openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {
+                    "role": "user",
+                    "content": [{"type": "text", "text": prompt}, {"type": "file", "file": {"file_id": openai_file.id}}]
+                }
+            ],
+            temperature=0
+        )
+        text = response.choices[0].message.content
+        self.openai_client.files.delete(openai_file.id)
+        return text
+
+    async def generate_outline(self, source_text: str, language: str = "Japanese", custom_prompt: str = "") -> Dict[str, Any]:
+        """Step 1: Generate Slide Outline (JSON) from text."""
+        template_path = "core/templates/ja_slide_template.yaml" if language == "Japanese" else "core/templates/eng_slide_template.yaml"
+        if not os.path.exists(template_path):
+            # Fallback if I missed copying
+            template_path = f"Temp/AI-Video-Summary-Generator/{'ja' if language == 'Japanese' else 'eng'}_slide_template.yaml"
+        
+        with open(template_path, "r", encoding="utf-8") as f:
+            template_yaml = f.read()
+
+        prompt = get_outline_prompt(template_yaml, source_text, custom_prompt, language)
+        
+        response = self.openai_client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.2,
+            response_format={"type": "json_object"}
+        )
+        return json.loads(response.choices[0].message.content)
+
+    async def create_slides_and_export_pdf(self, outline: Dict[str, Any], template_filename: str = "slide_template_v001.pptx") -> bytes:
+        """Step 2 & 3: Create Google Slides and export to PDF."""
+        slides_api, drive_api = self._get_clients()
+        
+        # 1. Get Template: Try local first, then GCS
+        pptx_path = os.path.join("core", "templates", template_filename)
+        if os.path.exists(pptx_path):
+            with open(pptx_path, "rb") as f:
+                pptx_bytes = f.read()
+        else:
+            logger.info(f"Template {template_filename} not found locally, trying GCS...")
+            try:
+                pptx_bytes = self._download_template_from_gcs(template_filename)
+            except Exception as e:
+                raise FileNotFoundError(f"Template {template_filename} not found locally or on GCS: {e}")
+
+        # 2. Upload and convert
+        media = MediaIoBaseUpload(io.BytesIO(pptx_bytes), mimetype="application/vnd.openxmlformats-officedocument.presentationml.presentation")
+        body = {
+            "name": f"Generated Video Source {int(time.time())}",
+            "mimeType": "application/vnd.google-apps.presentation",
+        }
+        
+        folder_id = os.environ.get("DRIVE_FOLDER_ID")
+        if folder_id:
+            body["parents"] = [folder_id]
+            
+        created = drive_api.files().create(body=body, media_body=media, supportsAllDrives=True, fields="id").execute()
+        pres_id = created["id"]
+
+        try:
+            # 3. Build slides from outline
+            self._build_from_outline(slides_api, pres_id, outline)
+            
+            # 4. Export to PDF
+            pdf_bytes = drive_api.files().export(
+                fileId=pres_id,
+                mimeType="application/pdf",
+            ).execute()
+            
+            return pdf_bytes
+        finally:
+            # Cleanup temp presentation
+            try:
+                drive_api.files().delete(fileId=pres_id).execute()
+            except:
+                pass
+
+    def _build_from_outline(self, slides, pres_id, outline):
+        """Port of build_from_outline from temp project."""
+        items = outline.get("slides", [])
+        initial = slides.presentations().get(presentationId=pres_id).execute()
+        original_page_ids = [p["objectId"] for p in initial.get("slides", [])]
+
+        for item in items:
+            tpl = item.get("template", "")
+            fields = item.get("fields", {})
+            
+            # Find base page
+            rep_key = TEMPLATE_HINT.get(tpl) or next(iter(fields.keys()), "")
+            base_page = self._find_page(slides, pres_id, rep_key)
+            if not base_page: continue
+
+            # Duplicate
+            resp = slides.presentations().batchUpdate(
+                presentationId=pres_id,
+                body={"requests": [{"duplicateObject": {"objectId": base_page}}]}
+            ).execute()
+            new_page = resp["replies"][0]["duplicateObject"]["objectId"]
+
+            # Move to end
+            pres_detail = slides.presentations().get(presentationId=pres_id).execute()
+            insertion_index = max(0, len(pres_detail.get("slides", [])) - 1)
+            slides.presentations().batchUpdate(
+                presentationId=pres_id,
+                body={"requests": [{
+                    "updateSlidesPosition": {
+                        "slideObjectIds": [new_page],
+                        "insertionIndex": insertion_index
+                    }
+                }]}
+            ).execute()
+
+            # Replace text
+            reqs = []
+            for k, v in fields.items():
+                reqs.append({
+                    "replaceAllText": {
+                        "containsText": {"text": f"{{{{{k}}}}}", "matchCase": False},
+                        "replaceText": str(v),
+                        "pageObjectIds": [new_page]
+                    }
+                })
+            if reqs:
+                slides.presentations().batchUpdate(presentationId=pres_id, body={"requests": reqs}).execute()
+
+            # Cleanup unused placeholders {{...}} on this slide (Matches original implementation)
+            try:
+                self._cleanup_placeholders(slides, pres_id, new_page, fields)
+            except Exception as e:
+                logger.warning(f"Placeholder cleanup failed for slide {new_page}: {e}")
+
+        # Delete originals
+        if original_page_ids:
+            reqs = [{"deleteObject": {"objectId": pid}} for pid in original_page_ids]
+            slides.presentations().batchUpdate(presentationId=pres_id, body={"requests": reqs}).execute()
+
+    def _cleanup_placeholders(self, slides, pres_id, page_id, fields):
+        """Finds all remaining {{TAGS}} and replaces them with empty strings."""
+        pres = slides.presentations().get(presentationId=pres_id).execute()
+        slide = next(s for s in pres.get("slides", []) if s.get("objectId") == page_id)
+        
+        found_tags = set()
+        for el in slide.get("pageElements", []):
+            text = el.get("shape", {}).get("text", {})
+            for te in text.get("textElements", []):
+                content = te.get("textRun", {}).get("content", "")
+                for m in re.findall(r"\{\{([A-Z0-9_.-]+)\}\}", content):
+                    found_tags.add(m)
+        
+        unused = [t for t in found_tags if t not in fields]
+        if unused:
+            reqs = [{
+                "replaceAllText": {
+                    "containsText": {"text": f"{{{{{t}}}}}", "matchCase": True},
+                    "replaceText": "",
+                    "pageObjectIds": [page_id]
+                }
+            } for t in unused]
+            slides.presentations().batchUpdate(presentationId=pres_id, body={"requests": reqs}).execute()
+
+    def _find_page(self, slides, pres_id, placeholder_key):
+        pres = slides.presentations().get(presentationId=pres_id).execute()
+        needle = f"{{{{{placeholder_key}}}}}"
+        for page in pres.get("slides", []):
+            for el in page.get("pageElements", []):
+                text = el.get("shape", {}).get("text", {})
+                for te in text.get("textElements", []):
+                    if needle in te.get("textRun", {}).get("content", ""):
+                        return page["objectId"]
+        return None
+
+    def _download_template_from_gcs(self, filename: str) -> bytes:
+        """Download template from GCS bucket (mimics Temp project logic)."""
+        bucket_name = settings.GCS_BUCKET
+        if not bucket_name:
+            raise RuntimeError("GCS_BUCKET environment variable is missing")
+        
+        # Path in bucket from Temp project: templates/filename
+        object_name = f"templates/{filename}"
+        
+        # Use SA if available, else default
+        info = self._get_sa_info()
+        if info:
+            creds = service_account.Credentials.from_service_account_info(info)
+            client = storage.Client(project=info.get("project_id"), credentials=creds)
+        else:
+            client = storage.Client()
+            
+        bucket = client.bucket(bucket_name)
+        blob = bucket.blob(object_name)
+        return blob.download_as_bytes()
+
+    async def generate_video_from_pdf_bytes(
+        self, 
+        pdf_bytes: bytes, 
+        language: str = "Japanese", 
+        voice_name: str = "Kore"
+    ) -> Dict[str, Any]:
+        """Step 4, 5, 6: PDF bytes -> Video Pipeline."""
+        temp_dir = tempfile.mkdtemp(prefix="video_final_")
+        try:
+            pdf_path = os.path.join(temp_dir, "source.pdf")
+            with open(pdf_path, "wb") as f:
+                f.write(pdf_bytes)
+
+            # 1. Images
+            images = convert_from_path(pdf_path, dpi=200)
+            total_pages = len(images)
+            image_paths = []
+            for i, img in enumerate(images, start=1):
+                p = os.path.join(temp_dir, f"p_{i:02d}.png")
+                img.save(p, "PNG")
+                image_paths.append(p)
+
+            # 2. Narration Script
+            with open(pdf_path, "rb") as f:
+                openai_file = self.openai_client.files.create(file=f, purpose="assistants")
+            
+            prompt = get_video_script_prompt(language, total_pages)
+            resp = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": [{"type": "text", "text": prompt}, {"type": "file", "file": {"file_id": openai_file.id}}]}],
+                response_format={"type": "json_object"},
+                temperature=0.3
+            )
+            script_data = json.loads(resp.choices[0].message.content)
+            scripts = script_data.get("scripts", [])
+            self.openai_client.files.delete(openai_file.id)
+
+            # 3. Audio & Video assembly (similar to existing logic but more refined)
+            page_clips = []
+            target_size = (1920, 1080)
+            
+            for i, img_path in enumerate(image_paths):
+                # Skip last slide narration if it's the logo slide (standard logic in temp project)
+                if i < len(scripts) and i < len(image_paths) - 1:
+                    text = scripts[i].get("script_text", "")
+                    audio_path = os.path.join(temp_dir, f"a_{i}.wav")
+                    
+                    # TTS with fallback
+                    try:
+                        model_name = "gemini-2.5-flash-preview-tts"
+                        logger.info(f"Generating audio for slide {i} using {model_name}...")
+                        tts_resp = self.gemini_client.models.generate_content(
+                            model=model_name,
+                            contents=text,
+                            config=types.GenerateContentConfig(
+                                response_modalities=["AUDIO"],
+                                speech_config=types.SpeechConfig(
+                                    voice_config=types.VoiceConfig(
+                                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                                            voice_name=voice_name
+                                        )
+                                    )
+                                )
+                            )
+                        )
+                    except Exception as tts_err:
+                        logger.warning(f"Failed with {model_name}, trying fallback gemini-1.5-flash: {tts_err}")
+                        model_name = "gemini-1.5-flash"
+                        tts_resp = self.gemini_client.models.generate_content(
+                            model=model_name,
+                            contents=text,
+                            config=types.GenerateContentConfig(
+                                response_modalities=["AUDIO"],
+                                speech_config=types.SpeechConfig(
+                                    voice_config=types.VoiceConfig(
+                                        prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                                            voice_name=voice_name
+                                        )
+                                    )
+                                )
+                            )
+                        )
+                    audio_data = tts_resp.candidates[0].content.parts[0].inline_data.data
+                    with wave.open(audio_path, "wb") as wf:
+                        wf.setnchannels(1); wf.setsampwidth(2); wf.setframerate(24000); wf.writeframes(audio_data)
+                    
+                    aud_clip = AudioFileClip(audio_path)
+                    duration = aud_clip.duration
+                    img_clip = ImageClip(self._prepare_img(img_path, target_size, temp_dir, i), duration=duration)
+                    page_clips.append(img_clip.with_audio(aud_clip))
+                    time.sleep(2)
+                else:
+                    # Silent 3s for last slide or missing scripts
+                    img_clip = ImageClip(self._prepare_img(img_path, target_size, temp_dir, i), duration=3.0)
+                    page_clips.append(img_clip)
+
+            final_path = os.path.join(temp_dir, "output.mp4")
+            final_clip = concatenate_videoclips(page_clips, method="compose")
+            final_clip.write_videofile(final_path, fps=24, codec="libx264", audio_codec="aac", logger=None)
+            
+            # Cleanup clips
+            for c in page_clips: c.close()
+            final_clip.close()
+
+            # Upload to S3
+            ts = int(time.time())
+            s3_key = f"users/video_summaries/{ts}_summary.mp4"
+            s3_service.s3_client.upload_file(final_path, settings.AWS_S3_BUCKET, s3_key)
+            s3_url = f"https://{settings.AWS_S3_BUCKET}.s3.{settings.AWS_REGION}.amazonaws.com/{s3_key}"
+
+            return {"s3_key": s3_key, "s3_url": s3_url}
+
+        finally:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+    def _prepare_img(self, path, size, temp_dir, idx):
+        img = Image.open(path)
+        img.thumbnail(size, Image.Resampling.LANCZOS)
+        new_img = Image.new("RGB", size, (0, 0, 0))
+        new_img.paste(img, ((size[0] - img.size[0]) // 2, (size[1] - img.size[1]) // 2))
+        res_path = os.path.join(temp_dir, f"ready_{idx}.png")
+        new_img.save(res_path)
+        return res_path
+
+    async def generate_transformed_video_summary(
+        self,
+        file_key: str,
+        language: str = "Japanese",
+        voice_name: str = "Kore",
+        custom_prompt: str = ""
+    ) -> Dict[str, Any]:
+        """
+        The Full Transformation Workflow: PDF -> Text -> Outline -> Slides -> PDF -> Video.
+        """
+        temp_dir = tempfile.mkdtemp(prefix="trans_video_")
+        try:
+            # 1. Download original PDF
+            pdf_path = os.path.join(temp_dir, "input.pdf")
+            s3_service.s3_client.download_file(settings.AWS_S3_BUCKET, file_key, pdf_path)
+
+            # 2. Extract Text
+            logger.info("Extracting text from PDF...")
+            source_text = await self.extract_text_from_pdf(pdf_path)
+
+            # 3. Generate Outline
+            logger.info("Generating slide outline...")
+            outline = await self.generate_outline(source_text, language, custom_prompt)
+
+            # 4. Create Slides and Export back to PDF (The Transformation)
+            logger.info("Building Google Slides and exporting...")
+            transformed_pdf_bytes = await self.create_slides_and_export_pdf(outline)
+
+            # 5. Generate Video from the Transformed PDF
+            logger.info("Generating video from transformed slides...")
+            result = await self.generate_video_from_pdf_bytes(transformed_pdf_bytes, language, voice_name)
+            
+            return {
+                "title": f"Transformed Summary - {os.path.basename(file_key)}",
+                "s3_key": result["s3_key"],
+                "s3_url": result["s3_url"]
+            }
+
+        finally:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+slides_video_service = SlidesVideoService()

services/video_generator_service.py

@@ -0,0 +1,225 @@
+import json
+import logging
+import os
+import tempfile
+import time
+import shutil
+from typing import List, Dict, Optional, Any
+import wave
+
+import openai
+from google import genai
+from google.genai import types
+from PIL import Image
+from pdf2image import convert_from_path
+from moviepy import ImageClip, AudioFileClip, VideoFileClip, concatenate_videoclips
+
+from core.config import settings
+from core.prompts import get_video_script_prompt
+from services.s3_service import s3_service
+
+logger = logging.getLogger(__name__)
+
+class VideoGeneratorService:
+    def __init__(self):
+        self.openai_client = openai.OpenAI(api_key=settings.OPENAI_API_KEY)
+        
+        # Match Temp project: Use API Key for Gemini TTS
+        logger.info("Initializing Gemini Client with API Key (as in Temp project)")
+        self.gemini_client = genai.Client(api_key=settings.GEMINI_API_KEY)
+
+    async def generate_video_summary(
+        self,
+        file_key: str,
+        language: str = "Japanese",
+        voice_name: str = "Kore"
+    ) -> Dict[str, Any]:
+        """
+        Complete pipeline: PDF -> Script -> Audio -> Images -> Video -> S3
+        """
+        temp_dir = tempfile.mkdtemp(prefix="video_gen_")
+        try:
+            # 1. Download PDF from S3
+            pdf_path = os.path.join(temp_dir, "input.pdf")
+            s3_service.s3_client.download_file(settings.AWS_S3_BUCKET, file_key, pdf_path)
+
+            # 2. Convert PDF to Images to get page count and for later use
+            image_dir = os.path.join(temp_dir, "images")
+            os.makedirs(image_dir, exist_ok=True)
+            
+            # Poppler check (Windows usually needs path)
+            poppler_path = os.environ.get("POPPLER_PATH")
+            if poppler_path:
+                images = convert_from_path(pdf_path, dpi=200, poppler_path=poppler_path)
+            else:
+                images = convert_from_path(pdf_path, dpi=200)
+            
+            total_pages = len(images)
+            image_paths = []
+            for i, img in enumerate(images, start=1):
+                img_path = os.path.join(image_dir, f"page_{i:02d}.png")
+                img.save(img_path, "PNG")
+                image_paths.append(img_path)
+
+            # 3. Generate Narration Script (OpenAI)
+            with open(pdf_path, "rb") as f:
+                openai_file = self.openai_client.files.create(file=f, purpose="assistants")
+            
+            # Using the new high-fidelity prompt
+            prompt = get_video_script_prompt(language, total_pages)
+            
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {
+                        "role": "user",
+                        "content": [
+                            {"type": "text", "text": prompt},
+                            {"type": "file", "file": {"file_id": openai_file.id}}
+                        ]
+                    }
+                ],
+                response_format={"type": "json_object"},
+                temperature=0.3
+            )
+            
+            script_data = json.loads(response.choices[0].message.content)
+            scripts = script_data.get("scripts", [])
+            
+            # Cleanup OpenAI file
+            self.openai_client.files.delete(openai_file.id)
+
+            # 4. Generate Audio for each page (Gemini TTS)
+            audio_dir = os.path.join(temp_dir, "audio")
+            os.makedirs(audio_dir, exist_ok=True)
+            audio_paths = []
+
+            # We iterate through scripts. Usually total_pages.
+            # Mirror original repo: last page (logo) is often skipped for audio.
+            for i, script in enumerate(scripts):
+                # If it's the last page, skip audio (standard behavior in the template project)
+                if i == len(scripts) - 1:
+                    logger.info(f"Skipping audio for last page (logo slide)")
+                    continue
+
+                page_num = script.get("page_number", i+1)
+                text = script.get("script_text", "")
+                if not text: continue
+
+                audio_path = os.path.join(audio_dir, f"audio_{page_num:02d}.wav")
+                
+                # Gemini TTS with fallback
+                try:
+                    # Default model from original repo
+                    model_name = "gemini-2.5-flash-preview-tts"
+                    logger.info(f"Generating audio for page {page_num} using {model_name}...")
+                    
+                    tts_resp = self.gemini_client.models.generate_content(
+                        model=model_name,
+                        contents=text,
+                        config=types.GenerateContentConfig(
+                            response_modalities=["AUDIO"],
+                            speech_config=types.SpeechConfig(
+                                voice_config=types.VoiceConfig(
+                                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                                        voice_name=voice_name
+                                    )
+                                )
+                            )
+                        )
+                    )
+                except Exception as tts_err:
+                    logger.warning(f"Failed with {model_name}, trying fallback gemini-1.5-flash: {tts_err}")
+                    # Fallback to a highly stable multimodal model
+                    model_name = "gemini-1.5-flash"
+                    tts_resp = self.gemini_client.models.generate_content(
+                        model=model_name,
+                        contents=text,
+                        config=types.GenerateContentConfig(
+                            response_modalities=["AUDIO"],
+                            speech_config=types.SpeechConfig(
+                                voice_config=types.VoiceConfig(
+                                    prebuilt_voice_config=types.PrebuiltVoiceConfig(
+                                        voice_name=voice_name
+                                    )
+                                )
+                            )
+                        )
+                    )
+                
+                audio_bytes = tts_resp.candidates[0].content.parts[0].inline_data.data
+                with wave.open(audio_path, "wb") as wf:
+                    wf.setnchannels(1)
+                    wf.setsampwidth(2)
+                    wf.setframerate(24000)
+                    wf.writeframes(audio_bytes)
+                
+                audio_paths.append(audio_path)
+                # Rate limiting guard: wait between audio gens
+                time.sleep(3)
+
+            # 5. Combine into individual videos and then final video (MoviePy)
+            page_clips = []
+            target_size = (1920, 1080)
+
+            for i, img_path in enumerate(image_paths):
+                # Match audio if available (some pages might not have script if script gen failed or skipped)
+                # Usually we want 1 image per audio.
+                if i < len(audio_paths):
+                    aud_clip = AudioFileClip(audio_paths[i])
+                    duration = aud_clip.duration
+                    
+                    # Process image to fit 1080p
+                    img = Image.open(img_path)
+                    img = self._resize_and_pad(img, target_size)
+                    temp_img_res = os.path.join(temp_dir, f"res_{i}.png")
+                    img.save(temp_img_res)
+                    
+                    img_clip = ImageClip(temp_img_res, duration=duration)
+                    vid_clip = img_clip.with_audio(aud_clip)
+                    page_clips.append(vid_clip)
+                else:
+                    # Final page or extra pages - silent 3s
+                    img = Image.open(img_path)
+                    img = self._resize_and_pad(img, target_size)
+                    temp_img_res = os.path.join(temp_dir, f"res_{i}.png")
+                    img.save(temp_img_res)
+                    img_clip = ImageClip(temp_img_res, duration=3.0)
+                    page_clips.append(img_clip)
+
+            final_video_path = os.path.join(temp_dir, "final.mp4")
+            final_clip = concatenate_videoclips(page_clips, method="compose")
+            final_clip.write_videofile(final_video_path, fps=24, codec="libx264", audio_codec="aac", logger=None)
+
+            # Cleanup clips
+            for clip in page_clips: clip.close()
+            if final_clip: final_clip.close()
+
+            # 6. Upload to S3
+            timestamp = int(time.time())
+            s3_key = f"users/video_summaries/{timestamp}_summary.mp4"
+            s3_service.s3_client.upload_file(final_video_path, settings.AWS_S3_BUCKET, s3_key)
+            s3_url = f"https://{settings.AWS_S3_BUCKET}.s3.{settings.AWS_REGION}.amazonaws.com/{s3_key}"
+
+            return {
+                "title": f"Video Summary - {os.path.basename(file_key)}",
+                "s3_key": s3_key,
+                "s3_url": s3_url
+            }
+
+        except Exception as e:
+            logger.error(f"Video generation failed: {e}")
+            import traceback
+            traceback.print_exc()
+            raise
+        finally:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+    def _resize_and_pad(self, img: Image.Image, size: tuple) -> Image.Image:
+        """Resizes image to fit in size while maintaining aspect ratio, adding black padding."""
+        img.thumbnail(size, Image.Resampling.LANCZOS)
+        new_img = Image.new("RGB", size, (0, 0, 0))
+        new_img.paste(img, ((size[0] - img.size[0]) // 2, (size[1] - img.size[1]) // 2))
+        return new_img
+
+video_generator_service = VideoGeneratorService()