Refactor: Move project to root of repository

.env.example

@@ -0,0 +1,3 @@
+GOOGLE_API_KEY=your_google_api_key_here
+DATABASE_URL=sqlite:///./data/talenttalk.db
+# Add other keys as needed (e.g., OPENAI_API_KEY if fallback is used)

.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# Environment Variables
+.env
+.env.local
+
+# IDE
+.vscode/
+.idea/
+
+# Media Files (Generated)
+*.mp3
+*.wav
+*.mp4
+temp_*
+static/audio/*
+
+# Logs
+*.log

backend/agents/gemini_client.py

@@ -0,0 +1,26 @@
+import google.generativeai as genai
+from ..core.config import get_settings
+
+settings = get_settings()
+
+def configure_genai():
+    genai.configure(api_key=settings.GOOGLE_API_KEY)
+
+def get_gemini_model(model_name: str = "gemini-1.5-flash", system_instruction: str = None):
+    configure_genai()
+    generation_config = {
+        "temperature": 0.7,
+        "top_p": 0.95,
+        "top_k": 40,
+        "max_output_tokens": 8192,
+    }
+    return genai.GenerativeModel(
+        model_name=model_name,
+        generation_config=generation_config,
+        system_instruction=system_instruction
+    )
+
+async def generate_response(prompt: str, system_instruction: str = None):
+    model = get_gemini_model(system_instruction=system_instruction)
+    response = await model.generate_content_async(prompt)
+    return response.text

backend/agents/workflow.py

@@ -0,0 +1,68 @@
+from typing import TypedDict, List, Annotated
+from langgraph.graph import StateGraph, END
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+import operator
+from .gemini_client import generate_response
+
+class InterviewState(TypedDict):
+    messages: Annotated[List[BaseMessage], operator.add]
+    candidate_id: int
+    current_stage: str # "introduction", "technical", "behavioral", "conclusion"
+    question_count: int
+
+async def interviewer_node(state: InterviewState):
+    messages = state["messages"]
+    stage = state.get("current_stage", "introduction")
+    
+    # Simple prompt logic for MVP - can be enhanced with complex prompt templates
+    system_prompt = f"""You are an expert technical interviewer conducting an interview.
+    Current Stage: {stage}
+    
+    Goal: Ask relevant questions based on the resume and previous answers. 
+    Be professional but encouraging. 
+    If the stage is 'introduction', ask about their background.
+    If 'technical', ask coding or system design questions.
+    If 'conclusion', thank them and wrap up.
+    """
+    
+    # Construct prompt from history
+    # For Gemini, we might need to format history carefully, but simple concatenation works for now
+    conversation = "\n".join([f"{m.type}: {m.content}" for m in messages])
+    prompt = f"{conversation}\nInterviewer:"
+    
+    response_text = await generate_response(prompt, system_instruction=system_prompt)
+    
+    return {"messages": [AIMessage(content=response_text)], "question_count": state.get("question_count", 0) + 1}
+
+def router_node(state: InterviewState):
+    # Logic to switch stages or end interview
+    count = state.get("question_count", 0)
+    stage = state.get("current_stage", "introduction")
+    
+    if stage == "introduction" and count >= 2:
+        return "technical"
+    elif stage == "technical" and count >= 5:
+        return "conclusion"
+    elif stage == "conclusion" and count >= 7:
+        return "end"
+    return "continue"
+
+# Define Graph
+workflow = StateGraph(InterviewState)
+workflow.add_node("interviewer", interviewer_node)
+workflow.set_entry_point("interviewer")
+
+def route_step(state: InterviewState):
+    decision = router_node(state)
+    if decision == "end":
+        return END
+    elif decision == "continue":
+        return END # For client-server model, we stop after generation and wait for user input
+    else:
+        # Update stage logic would go here, for now simple loop
+        # In a real app, we'd have a node to update state parameters
+        return END 
+
+workflow.add_edge("interviewer", END) # Simplified for Request/Response API pattern
+
+app_graph = workflow.compile()

backend/api_routes.py

@@ -0,0 +1,47 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from .agents.workflow import app_graph, InterviewState
+from langchain_core.messages import HumanMessage, AIMessage
+
+router = APIRouter()
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: str # Ideally used to load state from DB
+
+# In-memory store for MVP state (replace with Redis/DB in production)
+session_store = {}
+
+@router.post("/chat")
+async def chat_endpoint(request: ChatRequest):
+    session_id = request.session_id
+    user_input = request.message
+    
+    # Initialize state if new
+    if session_id not in session_store:
+        session_store[session_id] = {
+            "messages": [],
+            "candidate_id": 1, # Mock
+            "current_stage": "introduction",
+            "question_count": 0
+        }
+    
+    current_state = session_store[session_id]
+    
+    # Add user message
+    current_state["messages"].append(HumanMessage(content=user_input))
+    
+    # Run graph
+    # LangGraph invoke returns the final state
+    result = await app_graph.ainvoke(current_state)
+    
+    # Update store
+    session_store[session_id] = result
+    
+    # Get last message
+    last_message = result["messages"][-1]
+    
+    return {
+        "response": last_message.content,
+        "stage": result.get("current_stage")
+    }

backend/app/agents/interview_graph.py

@@ -0,0 +1,217 @@
+from typing import TypedDict, List, Dict, Any, Optional
+from langgraph.graph import StateGraph, END
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
+
+from app.services.gemini_service import gemini_service
+from app.core.logging_config import logger
+
+class InterviewState(TypedDict):
+    # Chat history
+    messages: List[BaseMessage]
+    history: List[str]
+    
+    # State tracking
+    current_question: Optional[str]
+    current_question_num: int
+    total_questions: int
+    follow_up_count: int # Current follow-ups for this question
+    max_follow_ups: int # Max allowed
+    
+    # Context
+    target_company: str
+    interview_style: str
+    job_role: str
+    difficulty: str
+    topic: str
+    resume_text: Optional[str] # New field
+    
+    # Results
+    analysis_data: List[Dict[str, Any]]
+    final_report: Optional[str]
+
+# --- Nodes ---
+
+async def generate_question_node(state: InterviewState):
+    """Node: Generates the next question or ends interview."""
+    logger.info(f"Generating question {state['current_question_num'] + 1}/{state['total_questions']}")
+    
+    question = await gemini_service.generate_question(
+        target_company=state["target_company"],
+        interview_style=state["interview_style"],
+        job_role=state["job_role"],
+        difficulty=state["difficulty"],
+        topic=state["topic"],
+        question_num=state["current_question_num"] + 1,
+        total_questions=state["total_questions"],
+        history=state["history"],
+        resume_text=state.get("resume_text")
+    )
+    
+    # Update state
+    state["current_question"] = question
+    state["current_question_num"] += 1
+    
+    # Add to message history (as AI)
+    state["messages"].append(AIMessage(content=question))
+    
+    # Reset follow-up count for new question
+    state["follow_up_count"] = 0
+    
+    return state
+
+async def generate_follow_up_node(state: InterviewState):
+    """Node: Generates a follow-up question."""
+    logger.info("Generating Follow-up Question...")
+    
+    last_user_msg = state["messages"][-1]
+    last_answer = last_user_msg.content if isinstance(last_user_msg, HumanMessage) else ""
+    
+    question = await gemini_service.generate_followup_question(
+        target_company=state["target_company"],
+        question=state["current_question"],
+        answer=last_answer
+    )
+    
+    # Update state
+    state["current_question"] = question
+    # Do NOT increment current_question_num, as it's the same topic
+    state["follow_up_count"] += 1
+    
+    # Add to message history
+    state["messages"].append(AIMessage(content=question))
+    
+    return state
+
+async def analyze_answer_node(state: InterviewState):
+    """Node: Analyzes the user's latest response."""
+    last_message = state["messages"][-1]
+    
+    if not isinstance(last_message, HumanMessage):
+        # Should not happen in normal flow
+        return state
+        
+    user_answer = last_message.content
+    
+    logger.info("Analyzing user answer...")
+    analysis = await gemini_service.analyze_response(
+        question=state["current_question"],
+        answer=user_answer,
+        job_role=state["job_role"],
+        difficulty=state["difficulty"]
+    )
+    
+    # Append analysis to list
+    if "analysis_data" not in state:
+        state["analysis_data"] = []
+    
+    # Store complete analysis object
+    analysis_record = {
+        "question": state["current_question"],
+        "answer": user_answer,
+        "analysis": analysis,
+        "question_num": state["current_question_num"]
+    }
+    state["analysis_data"].append(analysis_record)
+    
+    # Add context to history for the next question generator
+    # We include a brief summary so the AI knows how the user did, but not the full JSON
+    feedback_short = f"Question: {state['current_question']}\nAnswer: {user_answer}\nFeedback: {analysis.get('feedback', '')}"
+    state["history"].append(feedback_short)
+    
+    # Adaptive Difficulty Logic
+    # If strongly positive, increase difficulty. If negative, decrease.
+    # Simple implementation for now.
+    score = analysis.get("sentiment_score", 0)
+    current_diff = state["difficulty"]
+    
+    if score > 0.7 and current_diff == "Easy":
+        state["difficulty"] = "Medium"
+    elif score > 0.8 and current_diff == "Medium":
+        state["difficulty"] = "Hard"
+    elif score < 0.3 and current_diff == "Hard":
+        state["difficulty"] = "Medium"
+    elif score < 0.2 and current_diff == "Medium":
+        state["difficulty"] = "Easy"
+        
+    return state
+
+async def generate_report_node(state: InterviewState):
+    """Node: Generates the final report after all questions."""
+    logger.info("Generating Final Report...")
+    
+    # Prepare data for the prompt
+    interview_data_str = json.dumps(state["analysis_data"], indent=2)
+    
+    report = await gemini_service.generate_final_report(
+        target_company=state["target_company"],
+        job_role=state["job_role"],
+        interview_data=interview_data_str
+    )
+    
+    state["final_report"] = report
+    return state
+
+import json
+
+# --- Routing ---
+
+def route_interview(state: InterviewState):
+    """Decides whether to continue questioning, follow-up, or end."""
+    
+    # 1. Check if we should ask a follow-up
+    if state.get("follow_up_count", 0) < state.get("max_follow_ups", 0):
+        return "generate_follow_up"
+
+    if state["current_question_num"] >= state["total_questions"]:
+        return "generate_report"
+    return "generate_question"
+
+# --- Graph Definition ---
+
+workflow = StateGraph(InterviewState)
+
+workflow.add_node("generate_question", generate_question_node)
+workflow.add_node("generate_follow_up", generate_follow_up_node)
+workflow.add_node("analyze_answer", analyze_answer_node)
+workflow.add_node("generate_report", generate_report_node)
+
+# Entry point
+workflow.set_entry_point("generate_question")
+
+# Transition from Question extraction -> Wait for user input
+# NOTE: In a real API, we would pause here. 
+# For this graph, we assume the HumanMessage is injected into state 
+# externally before resuming. 
+# BUT `StateGraph` in basic form runs until END or interrupt.
+# Since we are building an API, we will likely run one step at a time or use `interrupt`.
+# For MVP simplicity: 
+# The "cycle" is: Generate Question -> END (Return to user) -> (User calls API) -> Analyze Answer -> Route
+
+# However, to visualize the logic:
+# generate_question -> END (user sees question)
+# ... User inputs answer ...
+# (Resume with answer) -> analyze_answer -> route -> generate_question/report
+
+# We will define the edge from analyze to route
+workflow.add_conditional_edges(
+    "analyze_answer",
+    route_interview,
+    {
+        "generate_question": "generate_question",
+        "generate_follow_up": "generate_follow_up",
+        "generate_report": "generate_report"
+    }
+)
+
+workflow.add_edge("generate_report", END)
+
+# We define the edge that "ends" a turn to wait for user input.
+# In LangGraph terms, `generate_question` finishes, and we return state to the caller.
+# The caller (FastAPI) will persist state.
+# When user replies, we invoke `analyze_answer` directly?
+# OR we define the full loop and use `interrupt_before`.
+
+# Let's use the explicit loop for clarity and compilation,
+# but at runtime we might use it differently.
+# Ideally: generate_question -> END.
+# Then user submits answer -> analyze_answer -> check condition.

backend/app/api_routes.py

@@ -0,0 +1,215 @@
+import shutil
+import os
+from uuid import uuid4
+from fastapi import APIRouter, UploadFile, File, HTTPException, Form
+from app.schemas import InterviewStartRequest, InterviewStartResponse, ChatResponse
+from app.agents.interview_graph import workflow
+from app.services.voice_service import voice_service
+from app.core.logging_config import logger
+
+router = APIRouter()
+
+# In-memory session store for MVP
+# In production, use Redis or the SQL database to persist LangGraph state
+SESSION_STORE = {}
+
+@router.post("/start", response_model=InterviewStartResponse)
+async def start_interview(request: InterviewStartRequest):
+    session_id = str(uuid4())
+    logger.info(f"Starting session {session_id} for {request.target_company}")
+    
+    # Initialize State
+    initial_state = {
+        "messages": [],
+        "history": [],
+        "current_question": None,
+        "current_question_num": 0,
+        "total_questions": 5, # Default to 5 questions
+        "target_company": request.target_company,
+        "interview_style": request.interview_style,
+        "job_role": request.job_role,
+        "difficulty": request.difficulty,
+        "topic": request.topic or "General",
+        "analysis_data": []
+    }
+    
+    # Compile graph
+    app = workflow.compile()
+    
+    # Run first step to get Q1
+    result = await app.ainvoke(initial_state)
+    
+    # Store state
+    SESSION_STORE[session_id] = result
+    
+    return InterviewStartResponse(
+        session_id=session_id,
+        message="Interview initialized.",
+        first_question=result["current_question"]
+    )
+
+@router.post("/start_with_resume", response_model=InterviewStartResponse)
+async def start_interview_with_resume(
+    target_company: str = Form("Google"),
+    job_role: str = Form("Senior Engineer"),
+    interview_style: str = Form("Professional"),
+    difficulty: str = Form("Medium"),
+    resume_file: UploadFile = File(...)
+):
+    session_id = str(uuid4())
+    logger.info(f"Starting Resume Session {session_id} for {target_company}")
+    logger.info(f"Received file: {resume_file.filename}, Size: unknown bytes")
+    
+    try:
+        # 1. Parsing Resume
+        from app.services.resume_service import resume_service
+        resume_text = await resume_service.extract_text(resume_file)
+        logger.info(f"Resume text extracted (First 50 chars): {resume_text[:50]}...")
+        
+        # 2. Init State
+        initial_state = {
+            "messages": [],
+            "history": [],
+            "current_question": None,
+            "current_question_num": 0,
+            "total_questions": 5, 
+            "target_company": target_company,
+            "interview_style": interview_style,
+            "job_role": job_role,
+            "difficulty": difficulty,
+            "topic": "Resume Review", # Override topic
+            "resume_text": resume_text,
+            "analysis_data": []
+        }
+        
+        # 3. Compile & Run
+        app = workflow.compile()
+        result = await app.ainvoke(initial_state)
+        
+        SESSION_STORE[session_id] = result
+        
+        return InterviewStartResponse(
+            session_id=session_id,
+            message="Interview initialized with Resume.",
+            first_question=result["current_question"]
+        )
+    except Exception as e:
+        logger.error(f"Error in start_with_resume: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Internal Server Error: {str(e)}")
+
+@router.post("/chat", response_model=ChatResponse)
+async def chat_interview(
+    session_id: str = Form(...),
+    text_input: str = Form(None),
+    audio_file: UploadFile = File(None)
+):
+    if session_id not in SESSION_STORE:
+        raise HTTPException(status_code=404, detail="Session not found")
+    
+    current_state = SESSION_STORE[session_id]
+    
+    # 1. Handle Input (Text or Audio)
+    user_response_text = ""
+    
+    if audio_file:
+        # Save temp file
+        temp_filename = f"temp_{session_id}_{uuid4()}.wav"
+        with open(temp_filename, "wb") as buffer:
+            shutil.copyfileobj(audio_file.file, buffer)
+            
+        try:
+            # Transcribe
+            user_response_text = await voice_service.transcribe_audio(temp_filename)
+        finally:
+            if os.path.exists(temp_filename):
+                os.remove(temp_filename)
+    elif text_input:
+        user_response_text = text_input
+    else:
+        raise HTTPException(status_code=400, detail="No input provided")
+
+    logger.info(f"User Response: {user_response_text}")
+
+    # 2. Update Context with User Answer
+    from langchain_core.messages import HumanMessage
+    current_state["messages"].append(HumanMessage(content=user_response_text))
+    
+    try:
+        # 3. Run Graph (Analyze -> Route -> Generate/Report)
+        from app.agents.interview_graph import analyze_answer_node, route_interview, generate_question_node, generate_report_node
+        
+        # A. Analyze
+        logger.info("Running analyze_answer_node...")
+        state = await analyze_answer_node(current_state)
+        feedback_item = state["analysis_data"][-1]
+        
+        # B. Route
+        next_step = route_interview(state)
+        logger.info(f"Next step routed: {next_step}")
+        
+        response_data = ChatResponse(
+            feedback=feedback_item["analysis"],
+            user_transcript=user_response_text
+        )
+        
+        if next_step == "generate_question":
+            # C. Generate Next Question
+            logger.info("Running generate_question_node...")
+            state = await generate_question_node(state)
+            response_data.question = state["current_question"]
+            
+            # D. Audio for Question (TTS)
+            os.makedirs("static/audio", exist_ok=True)
+            filename = f"q_{session_id}_{state['current_question_num']}.mp3"
+            filepath = os.path.join("static/audio", filename)
+            
+            try:
+                await voice_service.generate_audio(state["current_question"], filepath)
+                response_data.audio_url = f"/static/audio/{filename}"
+            except Exception as e:
+                logger.error(f"TTS failed: {e}")
+        
+        elif next_step == "generate_report":
+            # C. Generate Report
+            logger.info("Running generate_report_node...")
+            response_data.is_finished = True
+            state = await generate_report_node(state)
+            
+        # Update Store
+        SESSION_STORE[session_id] = state
+        
+        return response_data
+
+    except Exception as e:
+        logger.error(f"Error in chat_interview logic: {e}", exc_info=True)
+        import traceback
+        traceback.print_exc()
+        raise HTTPException(status_code=500, detail=f"Chat Error: {str(e)}")
+
+@router.get("/report/{session_id}")
+async def get_report(session_id: str):
+    if session_id not in SESSION_STORE:
+        raise HTTPException(status_code=404, detail="Session not found")
+        
+    state = SESSION_STORE[session_id]
+    if not state.get("final_report"):
+        return {"status": "in_progress"}
+        
+    return {"report": state["final_report"]}
+
+@router.post("/analyze_video")
+async def analyze_video(video_file: UploadFile = File(...)):
+    temp_filename = f"temp_video_{uuid4()}.mp4"
+    with open(temp_filename, "wb") as buffer:
+        shutil.copyfileobj(video_file.file, buffer)
+        
+    try:
+        from app.services.gemini_service import gemini_service
+        analysis = await gemini_service.analyze_video_behavior(temp_filename)
+        return {"analysis": analysis}
+    except Exception as e:
+        logger.error(f"Video analysis failed: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if os.path.exists(temp_filename):
+            os.remove(temp_filename)

backend/app/core/config.py

@@ -0,0 +1,43 @@
+import os
+from typing import List, Union
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import AnyHttpUrl, field_validator
+
+class Settings(BaseSettings):
+    API_V1_STR: str = "/api/v1"
+    PROJECT_NAME: str = "TalentTalk Pro"
+    
+    # CORS
+    BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = []
+
+    @field_validator("BACKEND_CORS_ORIGINS", mode="before")
+    def assemble_cors_origins(cls, v: Union[str, List[str]]) -> List[str]:
+        if isinstance(v, str) and not v.startswith("["):
+            return [i.strip() for i in v.split(",")]
+        elif isinstance(v, (list, str)):
+            return v
+        raise ValueError(v)
+
+    # Database
+    DATABASE_URL: str = "sqlite+aiosqlite:///./talenttalk.db"
+    
+    # OpenRouter
+    OPENROUTER_API_KEY: str
+    GOOGLE_API_KEY: str = "" # Optional fallback or for Multimodal if valid
+    
+    # Voice Services
+    ASSEMBLYAI_API_KEY: str = ""
+    ELEVENLABS_API_KEY: str = ""
+    
+    # Environment
+    ENVIRONMENT: str = "development"
+    LOG_LEVEL: str = "INFO"
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        case_sensitive=True,
+        extra="ignore"
+    )
+
+settings = Settings()

backend/app/core/logging_config.py

@@ -0,0 +1,43 @@
+import logging
+import sys
+import json
+from .config import settings
+
+class JsonFormatter(logging.Formatter):
+    def format(self, record):
+        log_obj = {
+            "timestamp": self.formatTime(record, self.datefmt),
+            "level": record.levelname,
+            "message": record.getMessage(),
+            "module": record.module,
+            "line": record.lineno,
+        }
+        if record.exc_info:
+            log_obj["exception"] = self.formatException(record.exc_info)
+        return json.dumps(log_obj)
+
+def setup_logging():
+    logger = logging.getLogger("talenttalk")
+    logger.setLevel(settings.LOG_LEVEL)
+    
+    console_handler = logging.StreamHandler(sys.stdout)
+    
+    if settings.ENVIRONMENT == "production":
+        console_handler.setFormatter(JsonFormatter())
+    else:
+        # Standard readable format for dev
+        formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        )
+        console_handler.setFormatter(formatter)
+        
+    logger.addHandler(console_handler)
+    
+    # Also capture uvicorn logs if in prod
+    if settings.ENVIRONMENT == "production":
+        uvicorn_logger = logging.getLogger("uvicorn.access")
+        uvicorn_logger.handlers = [console_handler]
+
+    return logger
+
+logger = setup_logging()

backend/app/core/prompts.py

@@ -0,0 +1,121 @@
+from langchain_core.prompts import PromptTemplate
+
+# Prompt for generating the next interview question
+QUESTION_PROMPT_TEMPLATE = """
+You are an expert technical interviewer for {target_company}. 
+You are conducting a {interview_style} interview for the role of {job_role}.
+
+Context:
+- Current Difficulty Level: {difficulty}
+- specific Topic (if any): {topic}
+- Question Number: {question_num} of {total_questions}
+
+Candidate's Resume Context:
+{resume_context}
+
+Your goal is to assess the candidate's skills, problem-solving abilities, and cultural fit for {target_company}.
+If the interview style is "Friendly", be encouraging and conversational.
+If "Professional", be formal and precise.
+If "HR", focus on behavioral and situational questions.
+If "Technical", focus on coding, system design, and deep technical concepts.
+If "Visual", assume the candidate can see you (describe your expression/gesture in brackets if needed).
+
+Previous Conversation History:
+{history}
+
+Generate the next interview question. 
+Keep it concise and clear. 
+Do not greet the candidate again if you have already done so in the history.
+Just output the question text.
+"""
+
+QUESTION_PROMPT = PromptTemplate(
+    input_variables=["target_company", "interview_style", "job_role", "difficulty", "topic", "question_num", "total_questions", "history", "resume_context"],
+    template=QUESTION_PROMPT_TEMPLATE
+)
+
+
+# Prompt for analyzing the candidate's response
+ANALYSIS_PROMPT_TEMPLATE = """
+You are an AI Interview Evaluator. 
+Analyze the candidate's response to the following question.
+
+Question: {question}
+Candidate's Answer: {answer}
+
+Context:
+- Role: {job_role}
+- Difficulty: {difficulty}
+
+Provide your analysis in the following JSON format ONLY:
+{{
+    "feedback": "Constructive feedback on the answer, highlighting strengths and weaknesses.",
+    "sentiment_score": 0.5,  // Float between -1.0 (Negative) and 1.0 (Positive)
+    "technical_accuracy": 0.8, // Float between 0.0 and 1.0
+    "suggested_improvement": "A better way to phrase or answer the question.",
+    "is_correct": true // Boolean
+}}
+"""
+
+ANALYSIS_PROMPT = PromptTemplate(
+    input_variables=["question", "answer", "job_role", "difficulty"],
+    template=ANALYSIS_PROMPT_TEMPLATE
+)
+
+
+# Prompt for generating the final comprehensive report
+FINAL_REPORT_PROMPT_TEMPLATE = """
+You are a Senior Talent Acquisition Specialist at {target_company}.
+You have just completed an interview with a candidate for the {job_role} position.
+
+Interview Data:
+{interview_data}
+
+Generate a comprehensive Final Analysis Report in Markdown format.
+The report should include the following sections:
+
+1. **Executive Summary**: A brief overview of the candidate's performance.
+
+2. **Full Interview Transcript**:
+   - List every Question asked and the Candidate's Answer.
+   - For each answer, provide a brief critique.
+
+3. **Detailed Analysis**:
+   - **Strengths**: Key areas where the candidate excelled.
+   - **Weaknesses**: Specific technical or behavioral gaps.
+   - **Sentiment & Confidence**: Breakdown of their tone and confidence level.
+
+4. **Actionable Suggestions**:
+   - Specific advice on how to improve for the next interview.
+   - Resources or topics to study if technical gaps were found.
+
+5. **Final Verdict**:
+   - **Recommendation**: Hiring recommendation (Strong Hire, Hire, No Hire) with justification.
+   - **Overall Rating**: Score out of 10.
+
+Tone: Professional, constructive, and encouraging.
+"""
+
+FINAL_REPORT_PROMPT = PromptTemplate(
+    input_variables=["target_company", "job_role", "interview_data"],
+    template=FINAL_REPORT_PROMPT_TEMPLATE
+)
+
+# Prompt for generating a follow-up question
+FOLLOWUP_PROMPT_TEMPLATE = """
+You are an expert technical interviewer for {target_company}.
+The candidate just answered your question: "{question}"
+Candidate's Answer: "{answer}"
+
+Your goal is to dig deeper. Generate a short, sharp follow-up question.
+- If the answer was vague, ask for clarification.
+- If the answer was good, ask about a specific edge case or trade-off related to their answer.
+- Keep it conversational.
+
+Just output the follow-up question text.
+"""
+
+FOLLOWUP_PROMPT = PromptTemplate(
+    input_variables=["target_company", "question", "answer"],
+    template=FOLLOWUP_PROMPT_TEMPLATE
+)

backend/app/db/database.py

@@ -0,0 +1,29 @@
+from typing import AsyncGenerator
+from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine
+from sqlalchemy.orm import sessionmaker
+from sqlmodel import SQLModel
+
+from app.core.config import settings
+
+# Create Async Engine
+# check_same_thread=False is needed only for SQLite. 
+connect_args = {"check_same_thread": False} if "sqlite" in settings.DATABASE_URL else {}
+
+engine = create_async_engine(
+    settings.DATABASE_URL,
+    echo=(settings.LOG_LEVEL == "DEBUG"),
+    connect_args=connect_args,
+    future=True
+)
+
+async def init_db():
+    async with engine.begin() as conn:
+        # await conn.run_sync(SQLModel.metadata.drop_all)
+        await conn.run_sync(SQLModel.metadata.create_all)
+
+async def get_session() -> AsyncGenerator[AsyncSession, None]:
+    async_session = sessionmaker(
+        engine, class_=AsyncSession, expire_on_commit=False
+    )
+    async with async_session() as session:
+        yield session

backend/app/main.py

@@ -0,0 +1,49 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from app.core.config import settings
+from app.core.logging_config import logger
+from app.db.database import init_db
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    logger.info("Startup: Initializing Application")
+    await init_db()
+    logger.info("Startup: Database initialized")
+    yield
+    # Shutdown
+    logger.info("Shutdown: Application stopping")
+
+from fastapi.staticfiles import StaticFiles
+from app.api_routes import router as api_router
+
+app = FastAPI(
+    title=settings.PROJECT_NAME,
+    openapi_url=f"{settings.API_V1_STR}/openapi.json",
+    lifespan=lifespan
+)
+
+# Mount static files for audio
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Set all CORS enabled origins
+if settings.BACKEND_CORS_ORIGINS:
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=[str(origin) for origin in settings.BACKEND_CORS_ORIGINS],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+app.include_router(api_router, prefix="/api/v1")
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy", "environment": settings.ENVIRONMENT}
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to TalentTalk Pro API", "docs": "/docs"}

backend/app/models/models.py

@@ -0,0 +1,77 @@
+from datetime import datetime
+from typing import Optional, List
+from enum import Enum
+from sqlmodel import SQLModel, Field, Relationship
+from uuid import UUID, uuid4
+from pydantic import EmailStr
+
+class UserRole(str, Enum):
+    ADMIN = "admin"
+    USER = "user"
+
+class InterviewStatus(str, Enum):
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+
+class DifficultyLevel(str, Enum):
+    EASY = "easy"
+    MEDIUM = "medium"
+    HARD = "hard"
+
+class InterviewStyle(str, Enum):
+    VISUAL = "visual"           # e.g., friendly, seeing the interviewer
+    PROFESSIONAL = "professional"
+    HR = "hr"
+    TECHNICAL = "technical"
+
+class User(SQLModel, table=True):
+    id: Optional[UUID] = Field(default_factory=uuid4, primary_key=True)
+    email: EmailStr = Field(index=True, unique=True)
+    hashed_password: str
+    role: UserRole = Field(default=UserRole.USER)
+    
+    sessions: List["InterviewSession"] = Relationship(back_populates="user")
+
+class InterviewSession(SQLModel, table=True):
+    id: Optional[UUID] = Field(default_factory=uuid4, primary_key=True)
+    user_id: UUID = Field(foreign_key="user.id")
+    job_role: str
+    difficulty_level: DifficultyLevel = Field(default=DifficultyLevel.MEDIUM)
+    interview_style: InterviewStyle = Field(default=InterviewStyle.PROFESSIONAL)
+    target_company: Optional[str] = None
+    status: InterviewStatus = Field(default=InterviewStatus.PENDING)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    final_analysis_report: Optional[str] = Field(default=None, description="JSON or text summary of the interview")
+
+    user: User = Relationship(back_populates="sessions")
+    questions: List["Question"] = Relationship(back_populates="session")
+
+class Question(SQLModel, table=True):
+    id: Optional[UUID] = Field(default_factory=uuid4, primary_key=True)
+    session_id: UUID = Field(foreign_key="interviewsession.id")
+    content: str
+    topic: Optional[str] = None
+    difficulty: Optional[str] = None
+    order: int
+    
+    session: InterviewSession = Relationship(back_populates="questions")
+    response: Optional["Response"] = Relationship(back_populates="question")
+
+class Response(SQLModel, table=True):
+    id: Optional[UUID] = Field(default_factory=uuid4, primary_key=True)
+    question_id: UUID = Field(foreign_key="question.id")
+    audio_url: Optional[str] = None
+    transcript: Optional[str] = None
+    sentiment_score: Optional[float] = None
+    
+    question: Question = Relationship(back_populates="response")
+    feedback: Optional["Feedback"] = Relationship(back_populates="response")
+
+class Feedback(SQLModel, table=True):
+    id: Optional[UUID] = Field(default_factory=uuid4, primary_key=True)
+    response_id: UUID = Field(foreign_key="response.id")
+    content: str
+    score: Optional[int] = None
+    
+    response: Response = Relationship(back_populates="feedback")

backend/app/schemas.py

@@ -0,0 +1,38 @@
+from pydantic import BaseModel, ConfigDict
+from typing import List, Optional, Dict, Any
+from uuid import UUID
+
+# --- Request Models ---
+
+class InterviewStartRequest(BaseModel):
+    target_company: str
+    job_role: str
+    interview_style: str
+    difficulty: str
+    topic: Optional[str] = None
+    max_follow_ups: int = 1 # Default to 1 follow-up per question
+
+class ChatRequest(BaseModel):
+    session_id: str
+    user_input: Optional[str] = None
+    audio_file_data: Optional[bytes] = None # For direct file upload if needed, usually handled via UploadFile
+
+class ReportRequest(BaseModel):
+    session_id: str
+
+# --- Response Models ---
+
+class InterviewStartResponse(BaseModel):
+    session_id: str
+    message: str
+    first_question: str
+
+class ChatResponse(BaseModel):
+    question: Optional[str] = None
+    audio_url: Optional[str] = None # URL to TTS audio
+    feedback: Optional[Dict[str, Any]] = None
+    user_transcript: Optional[str] = None # Transcribed text from audio
+    is_finished: bool = False
+
+class ReportResponse(BaseModel):
+    report_content: str

backend/app/services/gemini_service.py

@@ -0,0 +1,161 @@
+import json
+from typing import Dict, Any, List
+from langchain_openai import ChatOpenAI
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
+
+from app.core.config import settings
+from app.core.prompts import QUESTION_PROMPT, ANALYSIS_PROMPT, FINAL_REPORT_PROMPT, FOLLOWUP_PROMPT
+from app.core.logging_config import logger # Added for video analysis and error logging
+
+class GeminiService:
+    def __init__(self):
+        # OpenRouter Configuration
+        self.llm = ChatOpenAI(
+            model="google/gemini-2.0-flash-001",
+            openai_api_key=settings.OPENROUTER_API_KEY,
+            openai_api_base="https://openrouter.ai/api/v1",
+            temperature=0.7
+        )
+        self.json_llm = ChatOpenAI(
+            model="google/gemini-2.0-flash-001", 
+            openai_api_key=settings.OPENROUTER_API_KEY,
+            openai_api_base="https://openrouter.ai/api/v1",
+            temperature=0.3,
+            model_kwargs={"response_format": {"type": "json_object"}}
+        )
+
+    async def analyze_video_behavior(self, video_path: str) -> str:
+        """Analyzes a video file for behavioral cues and expressions."""
+        # Video analysis via OpenRouter (Multimodal) requires sending image frames or video URL.
+        # For MVP, we will stub this or use a simple text fallback since we can't upload files to OpenRouter easily via this SDK yet.
+        # Alternatively, we could keep the Google SDK *just* for this if a GOOGLE_API_KEY is present.
+        
+        if settings.GOOGLE_API_KEY:
+             try:
+                import google.generativeai as genai
+                import time
+                genai.configure(api_key=settings.GOOGLE_API_KEY)
+                model = genai.GenerativeModel('gemini-1.5-flash')
+                
+                logger.info(f"Uploading video {video_path} to Google for analysis...")
+                video_file = genai.upload_file(path=video_path)
+                
+                while video_file.state.name == "PROCESSING":
+                    time.sleep(1)
+                    video_file = genai.get_file(video_file.name)
+                    
+                if video_file.state.name == "FAILED":
+                    raise ValueError("Video processing failed by Gemini.")
+                    
+                prompt = "Analyze this interview video clip. Describe the candidate's facial expressions, body language, and apparent confidence level. Be concise."
+                response = model.generate_content([video_file, prompt])
+                return response.text
+             except Exception as e:
+                 logger.error(f"Google Video Analysis failed: {e}")
+                 return "Video analysis unavailable (Check Google API Key)."
+        
+        return "Video analysis requires a valid GOOGLE_API_KEY in addition to OpenRouter."
+
+    async def generate_question(
+        self, 
+        target_company: str,
+        interview_style: str,
+        job_role: str,
+        difficulty: str,
+        topic: str,
+        question_num: int,
+        total_questions: int,
+        history: List[str],
+        resume_text: str = None
+    ) -> str:
+        """Generates the next interview question based on context."""
+        
+        # Format history string
+        history_text = "\n".join(history) if history else "No previous history."
+        resume_context = resume_text if resume_text else "No resume provided."
+        
+        prompt = QUESTION_PROMPT.format(
+            target_company=target_company or "Generic Tech Company",
+            interview_style=interview_style,
+            job_role=job_role,
+            difficulty=difficulty,
+            topic=topic or "General",
+            question_num=question_num,
+            total_questions=total_questions,
+            history=history_text,
+            resume_context=resume_context
+        )
+        
+        response = await self.llm.ainvoke(prompt)
+        return response.content
+
+
+    async def generate_followup_question(
+        self,
+        target_company: str,
+        question: str,
+        answer: str
+    ) -> str:
+        """Generates a follow-up question based on the previous answer."""
+        
+        prompt = FOLLOWUP_PROMPT.format(
+            target_company=target_company or "Generic Tech Company",
+            question=question,
+            answer=answer
+        )
+        
+        response = await self.llm.ainvoke(prompt)
+        return response.content
+
+    async def analyze_response(
+        self, 
+        question: str, 
+        answer: str, 
+        job_role: str, 
+        difficulty: str
+    ) -> Dict[str, Any]:
+        """Analyzes the candidate's answer and returns structured data."""
+        
+        prompt = ANALYSIS_PROMPT.format(
+            question=question,
+            answer=answer,
+            job_role=job_role,
+            difficulty=difficulty
+        )
+        
+        try:
+            response = await self.json_llm.ainvoke(prompt)
+            content = response.content
+            # Cleanup json if needed
+            if "```json" in content:
+                content = content.replace("```json", "").replace("```", "").strip()
+            return json.loads(content)
+        except Exception as e:
+            logger.error(f"Analysis failed: {e}")
+            return {
+                "feedback": "Could not analyze response.",
+                "sentiment_score": 0.0,
+                "technical_accuracy": 0.0,
+                "suggested_improvement": "",
+                "is_correct": False,
+                "error": str(e)
+            }
+
+    async def generate_final_report(
+        self,
+        target_company: str,
+        job_role: str,
+        interview_data: str
+    ) -> str:
+        """Generates the comprehensive final markdown report."""
+        
+        prompt = FINAL_REPORT_PROMPT.format(
+            target_company=target_company or "Generic Tech Company",
+            job_role=job_role,
+            interview_data=interview_data
+        )
+        
+        response = await self.llm.ainvoke(prompt)
+        return response.content
+
+gemini_service = GeminiService()

backend/app/services/resume_service.py

@@ -0,0 +1,31 @@
+import io
+from pypdf import PdfReader
+from fastapi import UploadFile
+
+class ResumeService:
+    async def extract_text(self, file: UploadFile) -> str:
+        """Extracts text from a PDF file."""
+        content = await file.read()
+        file_obj = io.BytesIO(content)
+        
+        try:
+            reader = PdfReader(file_obj)
+            text = ""
+            if not reader.pages:
+                return "Error: Empty PDF or parsing failed."
+                
+            for page in reader.pages:
+                extracted = page.extract_text()
+                if extracted:
+                    text += extracted + "\n"
+            
+            if not text.strip():
+                return "Warning: No text could be extracted from this PDF. It might be an image scan."
+                
+            return text
+        except Exception as e:
+            # Fallback for non-pdf or error
+            print(f"Error in extract_text: {e}") # Print to stdout to capture in logs
+            return f"Error extracting resume: {str(e)}"
+
+resume_service = ResumeService()

backend/app/services/voice_service.py

@@ -0,0 +1,123 @@
+import os
+import asyncio
+from typing import Optional
+import assemblyai as aai
+from elevenlabs.client import ElevenLabs
+
+from app.core.config import settings
+from app.core.logging_config import logger
+
+class VoiceService:
+    def __init__(self):
+        # Initialize AssemblyAI
+        if settings.ASSEMBLYAI_API_KEY:
+            aai.settings.api_key = settings.ASSEMBLYAI_API_KEY
+            self.transcriber = aai.Transcriber()
+        else:
+            logger.warning("AssemblyAI API Key not found. STT will be disabled.")
+            self.transcriber = None
+
+        # Initialize ElevenLabs
+        if settings.ELEVENLABS_API_KEY:
+            self.elevenlabs = ElevenLabs(api_key=settings.ELEVENLABS_API_KEY)
+        else:
+            logger.warning("ElevenLabs API Key not found. TTS will be disabled.")
+            self.elevenlabs = None
+
+    async def transcribe_audio(self, file_path: str) -> str:
+        """Transcribes audio file using Google Gemini (Fallbacks to AssemblyAI if needed)."""
+        
+        # Method 1: Google Gemini (Multimodal) - Robust & supports many formats without FFMPEG
+        if settings.GOOGLE_API_KEY:
+            try:
+                import google.generativeai as genai
+                genai.configure(api_key=settings.GOOGLE_API_KEY)
+                
+                logger.info(f"Uploading audio {file_path} to Gemini...")
+                # Upload file
+                audio_file = genai.upload_file(path=file_path)
+                
+                # Prompt
+                model = genai.GenerativeModel('gemini-1.5-flash')
+                response = model.generate_content([
+                    "Transcribe this audio file verbatim. Output strictly the transcription text only.",
+                    audio_file
+                ])
+                
+                logger.info("Gemini Transcription complete.")
+                return response.text.strip()
+            except Exception as e:
+                logger.error(f"Gemini STT failed: {e}")
+                # Fallthrough to AssemblyAI
+        
+        # Method 2: AssemblyAI
+        if not self.transcriber:
+             raise ValueError("No Transcription service available (Gemini or AssemblyAI). check API Keys.")
+
+        logger.info(f"Transcribing audio with AssemblyAI: {file_path}")
+        
+        # AssemblyAI SDK is synchronous, run in executor
+        loop = asyncio.get_event_loop()
+        
+        try:
+            transcript = await loop.run_in_executor(
+                None, 
+                self.transcriber.transcribe, 
+                file_path
+            )
+            
+            if transcript.status == aai.TranscriptStatus.error:
+                raise Exception(transcript.error)
+                
+            return transcript.text
+        except Exception as e:
+            logger.error(f"AssemblyAI Transcription failed: {e}")
+            raise
+
+    async def generate_audio(self, text: str, output_path: str) -> Optional[str]:
+        """Generates audio from text using ElevenLabs."""
+        logger.info(f"ENTER generate_audio: {text[:20]}...")
+        if not self.elevenlabs:
+            logger.error("ElevenLabs not configured")
+            raise ValueError("ElevenLabs not configured.")
+
+        logger.info(f"Generating audio for: {text[:50]}...")
+        
+        try:
+            # Run blocking generation in executor
+            loop = asyncio.get_event_loop()
+            
+            # Use default voice for now
+            audio_generator = await loop.run_in_executor(
+                None,
+                lambda: self.elevenlabs.generate(
+                    text=text,
+                    voice="Rachel", # Default popular voice
+                    model="eleven_monolingual_v1"
+                )
+            )
+            
+            # Save to file
+            with open(output_path, "wb") as f:
+                for chunk in audio_generator:
+                    f.write(chunk)
+            
+            return output_path
+        except Exception as e:
+            logger.error(f"ElevenLabs TTS generation failed: {e}. Falling back to gTTS.")
+            
+            # Fallback: gTTS (Free)
+            try:
+                from gtts import gTTS
+                loop = asyncio.get_event_loop()
+                await loop.run_in_executor(
+                    None,
+                    lambda: gTTS(text=text, lang='en').save(output_path)
+                )
+                logger.info("gTTS generation successful.")
+                return output_path
+            except Exception as e_gtts:
+                logger.error(f"gTTS also failed: {e_gtts}")
+                raise
+
+voice_service = VoiceService()

backend/core/config.py

@@ -0,0 +1,14 @@
+from pydantic_settings import BaseSettings
+from functools import lru_cache
+
+class Settings(BaseSettings):
+    APP_NAME: str = "TalentTalk Pro"
+    GOOGLE_API_KEY: str
+    DATABASE_URL: str = "sqlite:///./data/talenttalk.db"
+    
+    class Config:
+        env_file = ".env"
+
+@lru_cache()
+def get_settings():
+    return Settings()

backend/core/database.py

@@ -0,0 +1,17 @@
+from sqlmodel import SQLModel, create_engine, Session
+from .config import get_settings
+
+settings = get_settings()
+
+engine = create_engine(
+    settings.DATABASE_URL, 
+    echo=True, 
+    connect_args={"check_same_thread": False}  # Needed for SQLite
+)
+
+def init_db():
+    SQLModel.metadata.create_all(engine)
+
+def get_session():
+    with Session(engine) as session:
+        yield session

backend/error_log.txt

@@ -0,0 +1 @@
+{"session_id":"de96fd7e-341f-4a39-a65f-b5c1ec2fa58a","message":"Interview initialized with Resume.","first_question":"Given the lack of resume information, let's start with a broad question.\n\nTell me about your experience with different types of testing methodologies.\n"}

backend/models/base.py

@@ -0,0 +1,17 @@
+from sqlmodel import SQLModel, Field
+from typing import Optional
+from datetime import datetime
+
+class Candidate(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    name: str
+    email: str
+    resume_path: Optional[str] = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+
+class InterviewSession(SQLModel, table=True):
+    id: Optional[int] = Field(default=None, primary_key=True)
+    candidate_id: int = Field(foreign_key="candidate.id")
+    role: str
+    status: str = "scheduled" # scheduled, in_progress, completed
+    created_at: datetime = Field(default_factory=datetime.utcnow)

backend/models_list.txt

@@ -0,0 +1,28 @@
+Fetching OpenRouter models...
+Available Google Models:
+google/gemini-3-flash-preview
+google/gemini-3-pro-image-preview
+google/gemini-3-pro-preview
+google/gemini-2.5-flash-image
+google/gemini-2.5-flash-preview-09-2025
+google/gemini-2.5-flash-lite-preview-09-2025
+google/gemini-2.5-flash-image-preview
+google/gemini-2.5-flash-lite
+google/gemma-3n-e2b-it:free
+google/gemini-2.5-flash
+google/gemini-2.5-pro
+google/gemini-2.5-pro-preview
+google/gemma-3n-e4b-it:free
+google/gemma-3n-e4b-it
+google/gemini-2.5-pro-preview-05-06
+google/gemma-3-4b-it:free
+google/gemma-3-4b-it
+google/gemma-3-12b-it:free
+google/gemma-3-12b-it
+google/gemma-3-27b-it:free
+google/gemma-3-27b-it
+google/gemini-2.0-flash-lite-001
+google/gemini-2.0-flash-001
+google/gemini-2.0-flash-exp:free
+google/gemma-2-27b-it
+google/gemma-2-9b-it

backend/output.txt

@@ -0,0 +1,4 @@
+Testing Resume Upload...
+Status Code: 500
+Response Body:
+{"detail":"Internal Server Error: Error code: 400 - {'error': {'message': 'google/gemini-1.5-flash is not a valid model ID', 'code': 400}, 'user_id': 'user_37yjw8tgNpQjTG3dKrdmjnj6Zba'}"}

backend/requirements.txt

@@ -0,0 +1,163 @@
+aiosqlite==0.22.1
+altair==6.0.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.12.1
+assemblyai==0.48.4
+asyncpg==0.31.0
+attrs==25.4.0
+backoff==2.2.1
+bcrypt==5.0.0
+blinker==1.9.0
+build==1.3.0
+cachetools==6.2.4
+certifi==2026.1.4
+charset-normalizer==3.4.4
+chromadb==1.4.0
+click==8.1.8
+colorama==0.4.6
+coloredlogs==15.0.1
+distro==1.9.0
+durationpy==0.10
+elevenlabs==2.28.0
+fastapi==0.128.0
+filelock==3.20.2
+filetype==1.2.0
+flatbuffers==25.12.19
+fsspec==2025.12.0
+gitdb==4.0.12
+GitPython==3.1.46
+google-ai-generativelanguage==0.6.15
+google-api-core==2.28.1
+google-api-python-client==2.187.0
+google-auth==2.47.0
+google-auth-httplib2==0.3.0
+google-genai==1.57.0
+google-generativeai==0.8.6
+googleapis-common-protos==1.72.0
+greenlet==3.3.0
+grpcio==1.76.0
+grpcio-status==1.71.2
+gTTS==2.5.4
+h11==0.16.0
+httpcore==1.0.9
+httplib2==0.31.0
+httptools==0.7.1
+httpx==0.28.1
+huggingface-hub==0.36.0
+humanfriendly==10.0
+idna==3.11
+importlib_metadata==8.7.1
+importlib_resources==6.5.2
+iniconfig==2.3.0
+Jinja2==3.1.6
+jiter==0.12.0
+joblib==1.5.3
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.26.0
+jsonschema-specifications==2025.9.1
+kubernetes==34.1.0
+langchain==1.2.2
+langchain-core==1.2.6
+langchain-google-genai==4.1.3
+langchain-openai==1.1.7
+langgraph==1.0.5
+langgraph-checkpoint==3.0.1
+langgraph-prebuilt==1.0.5
+langgraph-sdk==0.3.1
+langsmith==0.6.1
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+mmh3==5.2.0
+mpmath==1.3.0
+narwhals==2.15.0
+networkx==3.6.1
+numpy==2.4.0
+oauthlib==3.3.1
+onnxruntime==1.23.2
+openai==2.14.0
+opentelemetry-api==1.39.1
+opentelemetry-exporter-otlp-proto-common==1.39.1
+opentelemetry-exporter-otlp-proto-grpc==1.39.1
+opentelemetry-proto==1.39.1
+opentelemetry-sdk==1.39.1
+opentelemetry-semantic-conventions==0.60b1
+orjson==3.11.5
+ormsgpack==1.12.1
+overrides==7.7.0
+packaging==25.0
+pandas==2.3.3
+pillow==12.1.0
+pluggy==1.6.0
+posthog==5.4.0
+proto-plus==1.27.0
+protobuf==5.29.5
+pyarrow==22.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pybase64==1.4.3
+pydantic==2.12.5
+pydantic-settings==2.12.0
+pydantic_core==2.41.5
+pydeck==0.9.1
+Pygments==2.19.2
+PyMuPDF==1.26.7
+pyparsing==3.3.1
+pypdf==6.5.0
+PyPika==0.48.9
+pyproject_hooks==1.2.0
+pyreadline3==3.5.4
+pytest==9.0.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.1
+python-multipart==0.0.21
+pytz==2025.2
+PyYAML==6.0.3
+referencing==0.37.0
+regex==2025.11.3
+requests==2.32.5
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==14.2.0
+rpds-py==0.30.0
+rsa==4.9.1
+safetensors==0.7.0
+scikit-learn==1.8.0
+scipy==1.16.3
+sentence-transformers==5.2.0
+setuptools==80.9.0
+shellingham==1.5.4
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+SQLAlchemy==2.0.45
+sqlmodel==0.0.31
+starlette==0.50.0
+streamlit==1.52.2
+sympy==1.14.0
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tiktoken==0.12.0
+tokenizers==0.22.2
+toml==0.10.2
+torch==2.9.1
+tornado==6.5.4
+tqdm==4.67.1
+transformers==4.57.3
+typer==0.21.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.3
+uritemplate==4.2.0
+urllib3==2.3.0
+uuid_utils==0.12.0
+uvicorn==0.40.0
+watchdog==6.0.0
+watchfiles==1.1.1
+websocket-client==1.9.0
+websockets==15.0.1
+xxhash==3.6.0
+zipp==3.23.0
+zstandard==0.25.0

backend/services/resume_parser.py

@@ -0,0 +1,17 @@
+import fitz  # PyMuPDF
+from fastapi import UploadFile
+
+async def parse_resume(file: UploadFile) -> str:
+    """
+    Extracts text from a PDF file.
+    """
+    try:
+        content = await file.read()
+        doc = fitz.open(stream=content, filetype="pdf")
+        text = ""
+        for page in doc:
+            text += page.get_text()
+        return text
+    except Exception as e:
+        print(f"Error parsing resume: {e}")
+        return ""

backend/services/vector_store.py

@@ -0,0 +1,32 @@
+import chromadb
+from chromadb.utils import embedding_functions
+import os
+
+# Initialize ChromaDB Client
+# PersistentClient saves data to disk
+chroma_client = chromadb.PersistentClient(path="./data/chroma_db")
+
+# Use Google Generative AI Embeddings
+def get_embedding_function(api_key):
+    return embedding_functions.GoogleGenerativeAiEmbeddingFunction(api_key=api_key)
+
+def get_collection(name: str, api_key: str):
+    return chroma_client.get_or_create_collection(
+        name=name,
+        embedding_function=get_embedding_function(api_key)
+    )
+
+def add_documents(collection_name: str, documents: list, metadatas: list, ids: list, api_key: str):
+    collection = get_collection(collection_name, api_key)
+    collection.add(
+        documents=documents,
+        metadatas=metadatas,
+        ids=ids
+    )
+
+def query_documents(collection_name: str, query_text: str, n_results: int, api_key: str):
+    collection = get_collection(collection_name, api_key)
+    return collection.query(
+        query_texts=[query_text],
+        n_results=n_results
+    )

backend/start.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+# Install dependencies is handled by Render's build command usually, but we ensure uvicorn is ready.
+# Run Database Init (if we had migrations, we would run them here)
+# For now, just start the app
+echo "Starting TalentTalk Pro Backend..."
+python -m uvicorn app.main:app --host 0.0.0.0 --port $PORT

backend/test.pdf

@@ -0,0 +1,3 @@
+This is a dummy resume content for testing purposes.
+Skills: Python, FastAPI, AI.
+Experience: 5 years at Tech Corp.

backend/tests/list_openrouter_models.py

@@ -0,0 +1,34 @@
+import requests
+import os
+import sys
+
+sys.path.append(os.getcwd())
+from app.core.config import settings
+
+def list_models():
+    print("Fetching OpenRouter models...")
+    key = settings.OPENROUTER_API_KEY
+    if not key:
+        print("No OPENROUTER_API_KEY found.")
+        return
+
+    headers = {
+        "Authorization": f"Bearer {key}",
+    }
+    
+    try:
+        response = requests.get("https://openrouter.ai/api/v1/models", headers=headers)
+        if response.status_code == 200:
+            data = response.json()
+            # Filter for google models
+            google_models = [m['id'] for m in data['data'] if 'google' in m['id']]
+            print("Available Google Models:")
+            for m in google_models:
+                print(m)
+        else:
+            print(f"Failed: {response.status_code} - {response.text}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    list_models()

backend/tests/test_chat_audio.py

@@ -0,0 +1,49 @@
+import requests
+import json
+import os
+
+API_URL = "http://localhost:8000/api/v1"
+
+def create_dummy_wav(filename="test_audio.wav"):
+    # Create a minimal valid WAV file header
+    import wave
+    import struct
+    with wave.open(filename, 'w') as wav_file:
+        wav_file.setnchannels(1)
+        wav_file.setsampwidth(2)
+        wav_file.setframerate(44100)
+        # Write 1 second of silence
+        data = struct.pack('<h', 0) * 44100
+        wav_file.writeframes(data)
+
+def test_chat_audio():
+    create_dummy_wav()
+    
+    # 1. Start Interview
+    print("Starting Interview...")
+    start_res = requests.post(f"{API_URL}/start", json={
+        "target_company": "Google",
+        "job_role": "Python Dev",
+        "interview_style": "Professional",
+        "difficulty": "Medium"
+    })
+    
+    session_id = start_res.json()["session_id"]
+    print(f"Session ID: {session_id}")
+
+    # 2. Send Audio Message
+    print("Sending Audio Message...")
+    
+    # We must send session_id as data, and file in files
+    data = {"session_id": session_id}
+    files = {"audio_file": ("test_audio.wav", open("test_audio.wav", "rb"), "audio/wav")}
+    
+    try:
+        chat_res = requests.post(f"{API_URL}/chat", data=data, files=files)
+        print(f"Status: {chat_res.status_code}")
+        print(f"Response: {chat_res.text}")
+    except Exception as e:
+        print(f"Request Error: {e}")
+
+if __name__ == "__main__":
+    test_chat_audio()

backend/tests/test_chat_error.py

@@ -0,0 +1,38 @@
+import requests
+import json
+
+API_URL = "http://localhost:8000/api/v1"
+
+def test_chat():
+    # 1. Start Interview
+    print("Starting Interview...")
+    start_res = requests.post(f"{API_URL}/start", json={
+        "target_company": "Google",
+        "job_role": "Python Dev",
+        "interview_style": "Professional",
+        "difficulty": "Medium"
+    })
+    
+    if start_res.status_code != 200:
+        print(f"Start failed: {start_res.text}")
+        return
+
+    session_id = start_res.json()["session_id"]
+    print(f"Session ID: {session_id}")
+
+    # 2. Send Chat Message
+    print("Sending Chat Message...")
+    chat_payload = {
+        "session_id": session_id,
+        "text_input": "I have 5 years of experience with Python."
+    }
+    
+    try:
+        chat_res = requests.post(f"{API_URL}/chat", data=chat_payload)
+        print(f"Status: {chat_res.status_code}")
+        print(f"Response: {chat_res.text}")
+    except Exception as e:
+        print(f"Request Error: {e}")
+
+if __name__ == "__main__":
+    test_chat()

backend/tests/test_db_connection.py

@@ -0,0 +1,17 @@
+import pytest
+import asyncio
+from sqlalchemy import text
+from app.db.database import engine
+
+@pytest.mark.asyncio
+async def test_database_connection():
+    try:
+        async with engine.connect() as conn:
+            result = await conn.execute(text("SELECT 1"))
+            assert result.scalar() == 1
+        print("Database connection successful!")
+    except Exception as e:
+        pytest.fail(f"Database connection failed: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_database_connection())

backend/tests/test_followup_logic.py

@@ -0,0 +1,75 @@
+import requests
+import time
+
+API_URL = "http://localhost:8000/api/v1"
+
+def test_followup_flow():
+    print("🧪 Testing Follow-up Logic...")
+    
+    # 1. Start Interview with max_follow_ups = 1
+    print("\n1. Starting Session (max_follow_ups=1)...")
+    payload = {
+        "target_company": "TestCorp",
+        "job_role": "Tester",
+        "interview_style": "Professional",
+        "difficulty": "Easy",
+        "max_follow_ups": 1
+    }
+    
+    try:
+        res = requests.post(f"{API_URL}/start", json=payload)
+        res.raise_for_status()
+        data = res.json()
+        session_id = data["session_id"]
+        q1 = data["first_question"]
+        print(f"✅ Started. Session: {session_id}")
+        print(f"   Q1: {q1}")
+    except Exception as e:
+        print(f"❌ Failed to start: {e}")
+        return
+
+    # 2. Answer Q1 -> Expect Follow-up
+    print("\n2. Answering Q1 (Expect Follow-up)...")
+    chat_payload = {"session_id": session_id, "text_input": "I use print statements for debugging."}
+    
+    try:
+        res = requests.post(f"{API_URL}/chat", data=chat_payload)
+        res.raise_for_status()
+        data = res.json()
+        
+        reply = data.get("question", "")
+        print(f"   AI Reply: {reply}")
+        
+        # We can't strictly know if it's a follow-up by text, but based on logic flow it should be.
+        # Check feedback to confirm analysis happened
+        if data.get("feedback"):
+            print(f"   Feedback: {data['feedback']}")
+            
+        print("✅ Received response.")
+    except Exception as e:
+        print(f"❌ Failed Step 2: {e}")
+        return
+
+    # 3. Answer Follow-up -> Expect Q2
+    print("\n3. Answering Follow-up (Expect Q2)...")
+    chat_payload = {"session_id": session_id, "text_input": "I also use logging sometimes."}
+    
+    try:
+        res = requests.post(f"{API_URL}/chat", data=chat_payload)
+        res.raise_for_status()
+        data = res.json()
+        
+        reply = data.get("question", "")
+        print(f"   AI Reply: {reply}")
+        print("✅ Received response (Should be Q2).")
+        
+    except Exception as e:
+        print(f"❌ Failed Step 3: {e}")
+        return
+
+    print("\n🎉 Logic Flow Test Complete.")
+
+if __name__ == "__main__":
+    # Wait for server to be ready
+    time.sleep(3) 
+    test_followup_flow()

backend/tests/test_gemini_direct.py

@@ -0,0 +1,30 @@
+import asyncio
+import os
+import sys
+
+# Add backend to path
+sys.path.append(os.getcwd())
+
+from app.core.config import settings
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+async def test_gemini():
+    print("Testing Gemini Direct...")
+    print(f"API Key present: {bool(settings.GOOGLE_API_KEY)}")
+    
+    llm = ChatGoogleGenerativeAI(
+        model="gemini-pro",
+        google_api_key=settings.GOOGLE_API_KEY,
+        temperature=0.7
+    )
+    
+    print("Trying gemini-pro...")
+    
+    try:
+        response = await llm.ainvoke("Hello, this is a test.")
+        print(f"Response: {response.content}")
+    except Exception as e:
+        print(f"Gemini Failed: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_gemini())

backend/tests/test_genai_raw.py

@@ -0,0 +1,41 @@
+import google.generativeai as genai
+import os
+import sys
+
+# Add backend to path
+sys.path.append(os.getcwd())
+from app.core.config import settings
+
+def test_raw_genai():
+    print("Testing Raw GenAI...")
+    if not settings.GOOGLE_API_KEY:
+        print("No API Key found!")
+        return
+
+    genai.configure(api_key=settings.GOOGLE_API_KEY)
+    
+    # Try listing models
+    print("Listing models...")
+    try:
+        for m in genai.list_models():
+            if 'generateContent' in m.supported_generation_methods:
+                print(m.name)
+                break
+    except Exception as e:
+        print(f"List Models Failed: {e}")
+        
+    print(f"Loaded Key: {settings.GOOGLE_API_KEY[:5]}...{settings.GOOGLE_API_KEY[-5:]}")
+    
+    # Try generation
+    print("Generating content with gemini-pro...")
+    try:
+        model = genai.GenerativeModel('gemini-pro')
+        response = model.generate_content("Hello")
+        print(f"Response Success: {response.text[:20]}...")
+    except Exception as e:
+        print(f"Generation Failed: {e}")
+        # Print full type of error
+        print(type(e))
+
+if __name__ == "__main__":
+    test_raw_genai()

backend/tests/test_report_generation.py

@@ -0,0 +1,56 @@
+import asyncio
+import os
+import sys
+
+# Add backend to path (Correctly)
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from app.services.gemini_service import gemini_service
+
+async def test_report():
+    print("Testing Final Report Generation...")
+    
+    # Dummy Interview Data
+    interview_data = [
+        {
+            "question": "Explain the difference between a List and a Tuple in Python.",
+            "answer": "A list is mutable, meaning you can change it. A tuple is immutable. Lists use square brackets, tuples use parentheses.",
+            "analysis": {"feedback": "Good basic definition.", "sentiment_score": 0.8}
+        },
+        {
+            "question": "What is a decorator?",
+            "answer": "I am not sure, I think it decorates a function?",
+            "analysis": {"feedback": "Vague answer.", "sentiment_score": 0.3}
+        }
+    ]
+    
+    import json
+    data_str = json.dumps(interview_data, indent=2)
+    
+    try:
+        report = await gemini_service.generate_final_report(
+            target_company="Google",
+            job_role="Senior Python Developer",
+            interview_data=data_str
+        )
+        
+        print("\n--- GENERATED REPORT ---\n")
+        print(report)
+        print("\n------------------------\n")
+        
+        # Validation
+        if "Full Interview Transcript" in report:
+            print("✅ Section Found: Full Interview Transcript")
+        else:
+            print("❌ MISSING: Full Interview Transcript")
+            
+        if "Actionable Suggestions" in report:
+            print("✅ Section Found: Actionable Suggestions")
+        else:
+             print("❌ MISSING: Actionable Suggestions")
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(test_report())

backend/tests/test_resume_error.py

@@ -0,0 +1,39 @@
+import requests
+import io
+
+API_URL = "http://localhost:8000/api/v1"
+
+def test_resume_upload():
+    print("Testing Resume Upload...")
+    
+    # Create a dummy PDF file in memory
+    pdf_content = b"%PDF-1.5\n%..."
+    # Real minimal PDF header/trailer is better to avoid pypdf error if it validates
+    # But for a 500 server error, it might be even earlier.
+    # Let's try to use a real small valid pdf structure or just text if pypdf is lenient.
+    # Actually, let's create a minimal valid PDF using reportlab or fpdf if installed?
+    # No, let's just use a dummy text file renamed as .pdf and see if pypdf handles exception gracefully
+    # If pypdf crashes on invalid pdf, that might be the 500.
+    
+    dummy_pdf = io.BytesIO(b"This is a dummy pdf content")
+    
+    files = {'resume_file': ('test_resume.pdf', dummy_pdf, 'application/pdf')}
+    data = {
+        "target_company": "Test Corp",
+        "job_role": "Tester",
+        "interview_style": "Professional",
+        "difficulty": "Easy"
+    }
+    
+    try:
+        response = requests.post(f"{API_URL}/start_with_resume", files=files, data=data)
+        print(f"Status Code: {response.status_code}")
+        print("Response Body:")
+        print(response.text) # Print full text
+        with open("error_log.txt", "w", encoding="utf-8") as f:
+            f.write(response.text)
+    except Exception as e:
+        print(f"Request Failed: {e}")
+
+if __name__ == "__main__":
+    test_resume_upload()

backend/tests/test_service_only.py

@@ -0,0 +1,33 @@
+import asyncio
+from fastapi import UploadFile
+import io
+import sys
+import os
+
+# Add backend to path
+sys.path.append(os.getcwd())
+
+from app.services.resume_service import resume_service
+
+async def test_service():
+    print("Testing Resume Service Isolation...")
+    dummy_content = b"Draft Resume.\nName: John Doe.\nSkills: Python."
+    file_obj = io.BytesIO(dummy_content)
+    # UploadFile expects a 'file' attribute or we can mock it
+    # But wait, UploadFile has .read(). 
+    # Let's mock a class that behaves like UploadFile
+    class MockUploadFile:
+        filename = "test.pdf"
+        async def read(self):
+            return dummy_content
+            
+    try:
+        text = await resume_service.extract_text(MockUploadFile())
+        print(f"Extraction Result: {text}")
+    except Exception as e:
+        print(f"Service Execution Failed: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(test_service())

backend/tests/test_standard_start.py

@@ -0,0 +1,22 @@
+import requests
+
+API_URL = "http://localhost:8000/api/v1"
+
+def test_start():
+    print("Testing Standard Start...")
+    payload = {
+        "target_company": "Google",
+        "job_role": "Engineer",
+        "interview_style": "Professional",
+        "difficulty": "Medium"
+    }
+    
+    try:
+        response = requests.post(f"{API_URL}/start", json=payload)
+        print(f"Status Code: {response.status_code}")
+        print(f"Response: {response.text}")
+    except Exception as e:
+        print(f"Request Failed: {e}")
+
+if __name__ == "__main__":
+    test_start()

backend/tests/test_video_analysis.py

@@ -0,0 +1,43 @@
+import requests
+import os
+
+API_URL = "http://localhost:8000/api/v1"
+
+def test_video_analysis():
+    print("Testing Video Analysis Endpoint...")
+    
+    # Check if a dummy video exists, if not create a tiny dummy file
+    video_path = "dummy_video.mp4"
+    # Create dummy file if missing
+    if not os.path.exists(video_path):
+        with open(video_path, "wb") as f:
+            f.write(b"fake video content")
+
+    try:
+        # Open file in a with block to ensure it's closed before deletion cleanup
+        with open(video_path, 'rb') as f:
+            files = {'video_file': (video_path, f, 'video/mp4')}
+            response = requests.post(f"{API_URL}/analyze_video", files=files)
+        
+        print(f"Status Code: {response.status_code}")
+        print(f"Response: {response.text}")
+        
+        if response.status_code == 200:
+            print("✅ Video Analysis Endpoint reachable.")
+        else:
+             # It might fail analysis content-wise (fake video), but 500 or 200 is "handled"
+             # If API key is missing, it returns specific message
+             print(f"ℹ️ Endpoint Responded (Might be error from Gemini): {response.status_code}")
+
+    except Exception as e:
+        print(f"Error: {e}")
+    finally:
+        # Cleanup
+        if os.path.exists(video_path):
+            try:
+                os.remove(video_path)
+            except:
+                pass
+
+if __name__ == "__main__":
+    test_video_analysis()

backend/tests/test_workflow.py

@@ -0,0 +1,105 @@
+import asyncio
+import os
+from dotenv import load_dotenv
+
+# Ensure we can find the app module
+import sys
+sys.path.append(os.path.join(os.getcwd(), '..'))
+
+load_dotenv()
+
+from app.agents.interview_graph import workflow, InterviewState
+from langchain_core.messages import HumanMessage
+
+async def simulate_interview():
+    print("--- Starting Simulation ---")
+    
+    # Initialize State
+    initial_state = {
+        "messages": [],
+        "history": [],
+        "current_question": None,
+        "current_question_num": 0,
+        "total_questions": 2, # Short for testing
+        "target_company": "Google",
+        "interview_style": "Visual, Friendly", # Test new style
+        "job_role": "Senior Python Engineer",
+        "difficulty": "Medium",
+        "topic": "System Design",
+        "analysis_data": []
+    }
+    
+    app = workflow.compile()
+    
+    # 1. Generate First Question
+    print("\n[AI] Generating Q1...")
+    inputs = initial_state
+    
+    # We run until the first interruption or completion
+    # Since we didn't add interrupts, we have to invoke nodes manually 
+    # OR redefine the graph to interrupt.
+    # For this simulation, we will assume we can run step-by-step.
+    
+    # Run the 'generate_question' node
+    result = await app.ainvoke(inputs)
+    
+    # BUT, our graph has a loop: gen -> end. analyze -> route -> gen.
+    # The graph definition at the end: 
+    # workflow.add_node("generate_question", generate_question_node)
+    # workflow.set_entry_point("generate_question")
+    # No edge from generate_question means it hits END.
+    
+    # So `ainvoke` should run `generate_question` and stop.
+    state = result
+    print(f"\nAI: {state['current_question']}")
+    
+    # 2. Simulate User Answer to Q1
+    answer1 = "I would design a distributed system using sharding and replication."
+    print(f"\nUser: {answer1}")
+    
+    # Update state manually to inject answer (simulating API payload)
+    state["messages"].append(HumanMessage(content=answer1))
+    
+    # 3. Analyze Answer 1
+    # We need to continue the graph. 
+    # Since we hit END, we start a new run? No, that resets state.
+    # We should probably use `memory` (LangGraph checkpointer) if we want persistence.
+    # For now, let's treat the graph as a single-turn processor if possible, 
+    # OR run separate nodes directly for testing.
+    
+    # Let's run the 'analyze_answer' node directly on the current state
+    from app.agents.interview_graph import analyze_answer_node, route_interview, generate_question_node, generate_report_node
+    
+    print("\n[AI] Analyzing Q1...")
+    state = await analyze_answer_node(state)
+    print("Feedback:", state["history"][-1])
+    
+    # 4. Route
+    next_step = route_interview(state)
+    print(f"Next step: {next_step}")
+    
+    if next_step == "generate_question":
+        print("\n[AI] Generating Q2...")
+        state = await generate_question_node(state)
+        print(f"\nAI: {state['current_question']}")
+        
+        # 5. User Answer Q2
+        answer2 = "I'm not sure, maybe hash maps?"
+        print(f"\nUser: {answer2}")
+        state["messages"].append(HumanMessage(content=answer2))
+        
+        print("\n[AI] Analyzing Q2...")
+        state = await analyze_answer_node(state)
+        print("Feedback:", state["history"][-1])
+        
+        next_step = route_interview(state)
+        print(f"Next step: {next_step}")
+        
+    if next_step == "generate_report":
+        print("\n[AI] Generating Report...")
+        state = await generate_report_node(state)
+        print("\n--- FINAL REPORT ---\n")
+        print(state["final_report"])
+
+if __name__ == "__main__":
+    asyncio.run(simulate_interview())

frontend/app.py

@@ -0,0 +1,285 @@
+import streamlit as st
+import requests
+import json
+import time
+
+import os
+
+# Configuration
+API_URL = "http://localhost:8000/api/v1"
+
+# Try to get from Streamlit Secrets (Cloud)
+try:
+    if "API_URL" in st.secrets:
+        API_URL = st.secrets["API_URL"]
+except FileNotFoundError:
+    pass
+except Exception:
+    pass
+
+# Try OS Env (Docker/Render) - Overrides default
+if "API_URL" in os.environ:
+    API_URL = os.environ["API_URL"]
+
+st.set_page_config(
+    page_title="TalentTalk Pro",
+    page_icon="🎙️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main {
+        background-color: #f5f7f9;
+    }
+    .stChatMessage {
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+    }
+    .user-message {
+        background-color: #e3f2fd;
+    }
+    .ai-message {
+        background-color: #ffffff;
+        border: 1px solid #e0e0e0;
+    }
+    .stButton>button {
+        width: 100%;
+        border-radius: 20px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Session State Initialization
+if "session_id" not in st.session_state:
+    st.session_state.session_id = None
+if "messages" not in st.session_state:
+    st.session_state.messages = []
+if "interview_active" not in st.session_state:
+    st.session_state.interview_active = False
+
+def start_interview(company, role, style, difficulty, max_follow_ups):
+    payload = {
+        "target_company": company,
+        "job_role": role,
+        "interview_style": style,
+        "difficulty": difficulty,
+        "max_follow_ups": max_follow_ups
+    }
+    try:
+        response = requests.post(f"{API_URL}/start", json=payload)
+        response.raise_for_status()
+        data = response.json()
+        
+        st.session_state.session_id = data["session_id"]
+        st.session_state.interview_active = True
+        st.session_state.messages = []
+        
+        # Add AI greeting
+        st.session_state.messages.append({"role": "assistant", "content": data["first_question"]})
+        st.rerun()
+    except Exception as e:
+        st.error(f"Failed to start interview: {e}")
+
+def send_response(text_input, audio_file=None):
+    if not st.session_state.session_id:
+        return
+
+    # Add user message to UI immediately for responsiveness
+    if text_input:
+        st.session_state.messages.append({"role": "user", "content": text_input})
+    elif audio_file:
+         st.session_state.messages.append({"role": "user", "content": "🎤 Audio Response Sent"})
+
+    with st.spinner("Interviewer is thinking..."):
+        try:
+            files = None
+            data = {"session_id": st.session_state.session_id}
+            
+            if audio_file:
+                files = {"audio_file": ("answer.wav", audio_file, "audio/wav")}
+            if text_input:
+                data["text_input"] = text_input
+
+            response = requests.post(f"{API_URL}/chat", data=data, files=files)
+            response.raise_for_status()
+            result = response.json()
+            
+            # Update User Message with Transcript
+            if result.get("user_transcript"):
+                # If the last message was the placeholder, update it
+                if st.session_state.messages and st.session_state.messages[-1]["role"] == "user":
+                     st.session_state.messages[-1]["content"] = f"🎤 {result['user_transcript']}"
+
+            # Display Feedback from Interviewer
+            if result.get("feedback"):
+                feedback_data = result["feedback"]
+                # feedback_data is likely a dict or string depending on Gemini's JSON output
+                # Let's extract a friendly message.
+                feedback_text = ""
+                if isinstance(feedback_data, dict):
+                    feedback_text = feedback_data.get("feedback", "")
+                else:
+                    feedback_text = str(feedback_data)
+                
+                if feedback_text:
+                    st.session_state.messages.append({"role": "assistant", "content": f"**Feedback:** {feedback_text}"})
+
+            if result.get("question"):
+                st.session_state.messages.append({"role": "assistant", "content": result["question"], "audio_url": result.get("audio_url")})
+            
+            if result.get("is_finished"):
+                st.session_state.interview_active = False
+                st.session_state.messages.append({"role": "system", "content": "Interview Complete. Generating Report..."})
+                # Fetch Report
+                report_res = requests.get(f"{API_URL}/report/{st.session_state.session_id}")
+                if report_res.status_code == 200:
+                    report_data = report_res.json()
+                    st.session_state.final_report = report_data.get("report")
+
+            st.rerun()
+
+        except requests.exceptions.HTTPError as err:
+            # Try to get detailed error from backend
+            try:
+                error_detail = err.response.json().get("detail", err.response.text)
+                st.error(f"Backend Error: {error_detail}")
+            except:
+                st.error(f"HTTP Error: {err}")
+        except Exception as e:
+            st.error(f"Error sending message: {e}")
+
+# --- Sidebar ---
+with st.sidebar:
+    st.title("TalentTalk Pro 🚀")
+    st.header("Setup Interview")
+    
+    target_company = st.text_input("Target Company", "Google")
+    job_role = st.text_input("Job Role", "Senior Python Developer")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        difficulty = st.selectbox("Difficulty", ["Easy", "Medium", "Hard"])
+    with col2:
+        style = st.selectbox("Style", ["Professional", "Friendly", "HR", "Technical"])
+    
+    # Follow-up Depth Slider
+    max_follow_ups = st.slider("Step-by-step Follow-ups (Depth)", 0, 3, 1, 
+                               help="How many follow-up questions to ask per main topic.")
+    
+    # Resume Upload
+    resume_file = st.file_uploader("📄 Upload Resume (PDF)", type=["pdf"])
+        
+    if not st.session_state.interview_active:
+        if st.button("Start Interview", type="primary"):
+            if resume_file:
+                # Start with resume
+                try:
+                    with st.spinner("Analyzing Resume..."):
+                        files = {"resume_file": ("resume.pdf", resume_file, "application/pdf")}
+                        data = {
+                            "target_company": target_company,
+                            "job_role": job_role,
+                            "interview_style": style,
+                            "job_role": job_role,
+                            "interview_style": style,
+                            "difficulty": difficulty,
+                            "max_follow_ups": max_follow_ups
+                        }
+                        response = requests.post(f"{API_URL}/start_with_resume", data=data, files=files)
+                        response.raise_for_status()
+                        res_data = response.json()
+                        
+                        st.session_state.session_id = res_data["session_id"]
+                        st.session_state.interview_active = True
+                        st.session_state.messages = [{"role": "assistant", "content": res_data["first_question"]}]
+                        st.rerun()
+                except requests.exceptions.HTTPError as e:
+                    error_msg = "Unknown Error"
+                    try:
+                        error_msg = e.response.json().get("detail", str(e))
+                    except:
+                        error_msg = str(e)
+                    st.error(f"Failed to start with resume: {error_msg}")
+                except Exception as e:
+                    st.error(f"Failed to start with resume: {e}")
+            else:
+                # Standard Start
+                start_interview(target_company, job_role, style, difficulty, max_follow_ups)
+    else:
+        if st.button("End Interview", type="secondary"):
+            st.session_state.interview_active = False
+            st.rerun()
+            
+    st.markdown("---")
+    if st.session_state.get("final_report"):
+        st.success("Report Generated!")
+        with st.expander("View Final Report", expanded=True):
+            st.markdown(st.session_state.final_report)
+
+# --- Main Interaction Area ---
+
+st.title("AI Interview Session")
+
+# Chat Container
+chat_container = st.container()
+
+with chat_container:
+    for msg in st.session_state.messages:
+        with st.chat_message(msg["role"]):
+            st.write(msg["content"])
+            if msg.get("audio_url"):
+                # Construct full URL - ensure backend port is reachable
+                # In docker/prod this needs proper handling. 
+                # For local: http://localhost:8000 + url
+                audio_full_url = f"http://localhost:8000{msg['audio_url']}"
+                st.audio(audio_full_url, autoplay=True)
+
+# Input Area (Fixed at bottom)
+if st.session_state.interview_active:
+    st.markdown("---")
+    col_text, col_audio = st.columns([0.8, 0.2])
+    
+    with col_text:
+        text_input = st.chat_input("Type your answer here...")
+        if text_input:
+            send_response(text_input)
+            
+    with col_audio:
+        # Media Uploader
+        media_type = st.radio("Input Type", ["Audio", "Video"], horizontal=True, label_visibility="collapsed")
+        
+        if media_type == "Audio":
+            # Using native Streamlit audio input (requires Streamlit 1.40+)
+            audio_value = st.audio_input("🎤 Record your answer")
+            if audio_value:
+                 # Automatically send when recording stops? Or require button?
+                 # st.audio_input returns a file-like object.
+                 if st.button("Send Audio Answer", type="primary"):
+                     send_response(None, audio_value)
+        else:
+            uploaded_video = st.file_uploader("📹 Upload Video", type=["mp4", "mov"], key="video_uploader")
+            if uploaded_video:
+                if st.button("Analyze Video Behavior"):
+                    with st.spinner("Analyzing Video..."):
+                        try:
+                            video_files = {"video_file": ("video.mp4", uploaded_video, "video/mp4")}
+                            res = requests.post(f"{API_URL}/analyze_video", files=video_files)
+                            if res.status_code == 200:
+                                analysis = res.json().get("analysis")
+                                st.success("Video Analyzed!")
+                                st.info(analysis)
+                                # Append to chat as system note
+                                st.session_state.messages.append({"role": "system", "content": f"**Video Analysis:** {analysis}"})
+                            else:
+                                st.error("Analysis Failed")
+                        except Exception as e:
+                            st.error(f"Error: {e}")
+
+elif st.session_state.get("final_report"):
+    st.balloons()
+    st.markdown("## 📊 Interview Performance Report")
+    st.markdown(st.session_state.final_report)

frontend/requirements.txt

@@ -0,0 +1,163 @@
+aiosqlite==0.22.1
+altair==6.0.0
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.12.1
+assemblyai==0.48.4
+asyncpg==0.31.0
+attrs==25.4.0
+backoff==2.2.1
+bcrypt==5.0.0
+blinker==1.9.0
+build==1.3.0
+cachetools==6.2.4
+certifi==2026.1.4
+charset-normalizer==3.4.4
+chromadb==1.4.0
+click==8.1.8
+colorama==0.4.6
+coloredlogs==15.0.1
+distro==1.9.0
+durationpy==0.10
+elevenlabs==2.28.0
+fastapi==0.128.0
+filelock==3.20.2
+filetype==1.2.0
+flatbuffers==25.12.19
+fsspec==2025.12.0
+gitdb==4.0.12
+GitPython==3.1.46
+google-ai-generativelanguage==0.6.15
+google-api-core==2.28.1
+google-api-python-client==2.187.0
+google-auth==2.47.0
+google-auth-httplib2==0.3.0
+google-genai==1.57.0
+google-generativeai==0.8.6
+googleapis-common-protos==1.72.0
+greenlet==3.3.0
+grpcio==1.76.0
+grpcio-status==1.71.2
+gTTS==2.5.4
+h11==0.16.0
+httpcore==1.0.9
+httplib2==0.31.0
+httptools==0.7.1
+httpx==0.28.1
+huggingface-hub==0.36.0
+humanfriendly==10.0
+idna==3.11
+importlib_metadata==8.7.1
+importlib_resources==6.5.2
+iniconfig==2.3.0
+Jinja2==3.1.6
+jiter==0.12.0
+joblib==1.5.3
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.26.0
+jsonschema-specifications==2025.9.1
+kubernetes==34.1.0
+langchain==1.2.2
+langchain-core==1.2.6
+langchain-google-genai==4.1.3
+langchain-openai==1.1.7
+langgraph==1.0.5
+langgraph-checkpoint==3.0.1
+langgraph-prebuilt==1.0.5
+langgraph-sdk==0.3.1
+langsmith==0.6.1
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+mdurl==0.1.2
+mmh3==5.2.0
+mpmath==1.3.0
+narwhals==2.15.0
+networkx==3.6.1
+numpy==2.4.0
+oauthlib==3.3.1
+onnxruntime==1.23.2
+openai==2.14.0
+opentelemetry-api==1.39.1
+opentelemetry-exporter-otlp-proto-common==1.39.1
+opentelemetry-exporter-otlp-proto-grpc==1.39.1
+opentelemetry-proto==1.39.1
+opentelemetry-sdk==1.39.1
+opentelemetry-semantic-conventions==0.60b1
+orjson==3.11.5
+ormsgpack==1.12.1
+overrides==7.7.0
+packaging==25.0
+pandas==2.3.3
+pillow==12.1.0
+pluggy==1.6.0
+posthog==5.4.0
+proto-plus==1.27.0
+protobuf==5.29.5
+pyarrow==22.0.0
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pybase64==1.4.3
+pydantic==2.12.5
+pydantic-settings==2.12.0
+pydantic_core==2.41.5
+pydeck==0.9.1
+Pygments==2.19.2
+PyMuPDF==1.26.7
+pyparsing==3.3.1
+pypdf==6.5.0
+PyPika==0.48.9
+pyproject_hooks==1.2.0
+pyreadline3==3.5.4
+pytest==9.0.2
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.1
+python-multipart==0.0.21
+pytz==2025.2
+PyYAML==6.0.3
+referencing==0.37.0
+regex==2025.11.3
+requests==2.32.5
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==14.2.0
+rpds-py==0.30.0
+rsa==4.9.1
+safetensors==0.7.0
+scikit-learn==1.8.0
+scipy==1.16.3
+sentence-transformers==5.2.0
+setuptools==80.9.0
+shellingham==1.5.4
+six==1.17.0
+smmap==5.0.2
+sniffio==1.3.1
+SQLAlchemy==2.0.45
+sqlmodel==0.0.31
+starlette==0.50.0
+streamlit==1.52.2
+sympy==1.14.0
+tenacity==9.1.2
+threadpoolctl==3.6.0
+tiktoken==0.12.0
+tokenizers==0.22.2
+toml==0.10.2
+torch==2.9.1
+tornado==6.5.4
+tqdm==4.67.1
+transformers==4.57.3
+typer==0.21.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.3
+uritemplate==4.2.0
+urllib3==2.3.0
+uuid_utils==0.12.0
+uvicorn==0.40.0
+watchdog==6.0.0
+watchfiles==1.1.1
+websocket-client==1.9.0
+websockets==15.0.1
+xxhash==3.6.0
+zipp==3.23.0
+zstandard==0.25.0

render.yaml

@@ -0,0 +1,13 @@
+services:
+  - type: web
+    name: talenttalk-backend
+    env: python
+    buildCommand: cd backend && pip install -r requirements.txt
+    startCommand: cd backend && bash start.sh
+    envVars:
+      - key: PYTHON_VERSION
+        value: 3.11.0
+      - key: OPENROUTER_API_KEY
+        fromGroup: talenttalk-secrets
+      - key: GOOGLE_API_KEY
+        fromGroup: talenttalk-secrets

requirements.txt

@@ -0,0 +1,15 @@
+fastapi
+uvicorn
+streamlit
+langgraph
+langchain
+langchain-google-genai
+python-dotenv
+pydantic
+sqlmodel
+chromadb
+python-multipart
+requests
+google-generativeai
+sentence_transformers
+watchdog

run_backend.bat

@@ -0,0 +1,3 @@
+@echo off
+call venv\Scripts\activate
+uvicorn backend.main:app --reload --host 0.0.0.0 --port 8000

run_frontend.bat

@@ -0,0 +1,3 @@
+@echo off
+call venv\Scripts\activate
+streamlit run frontend/app.py