setting up docker to be able to deploy the in streamlit app.

.dockerignore

@@ -0,0 +1,18 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.env
+*.pdf
+.git
+.gitignore
+.pytest_cache
+.coverage
+htmlcov/
+dist/
+build/
+*.egg-info/
+.DS_Store 

.gitignore

@@ -1,4 +1,6 @@
 .env
 __pycache__/
 hype_pack/depricated_files/
-.DS_Store
+.DS_Store
+audio_out/
+.whisper

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.analysis.typeCheckingMode": "basic"
+}

Dockerfile

@@ -0,0 +1,32 @@
+# Use Python 3.11 as base image (compatible with your Poetry requirements)
+FROM python:3.11-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Poetry
+RUN curl -sSL https://install.python-poetry.org | python3 -
+
+# Copy only requirements first to leverage Docker cache
+COPY pyproject.toml poetry.lock ./
+
+# Configure Poetry to not create a virtual environment in the container
+RUN poetry config virtualenvs.create false
+
+# Install dependencies
+RUN poetry install --no-dev --no-interaction --no-ansi
+
+# Copy the rest of the application
+COPY . .
+
+# Expose the port Streamlit runs on
+EXPOSE 8501
+
+# Command to run the application
+CMD ["poetry", "run", "streamlit", "run", "hype_pack/streamlit_app.py", "--server.address=0.0.0.0"] 

docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3.8'
+
+services:
+  hypecast:
+    build: .
+    ports:
+      - "8501:8501"
+    volumes:
+      - .:/app
+    environment:
+      - OPENAI_API_KEY=${OPENAI_API_KEY}
+      - LMNT_API_KEY=${LMNT_API_KEY}
+      - GOOGLE_API_KEY=${GOOGLE_API_KEY}

hype_pack/utils/nodes.py

@@ -1,40 +1,387 @@
+from typing import List
 from langchain_openai import ChatOpenAI
 from langchain.prompts import ChatPromptTemplate
-from hype_pack.utils.state import InterviewState, ReferenceMaterial
+from hype_pack.utils.state import InterviewState, ReferenceMaterial, QuestionList, HypeCastTranscript
+import asyncio
+import os
+from dotenv import load_dotenv
+from lmnt.api import Speech
+import time
+
+
+load_dotenv()
+
+
 
 def build_reference_material_node(interview_state: InterviewState) -> InterviewState:
     """
-    Analyzes candidate background and job requirements to generate structured reference material.
+    Analyzes candidate background to generate material for motivational speeches.
     """
-
-    # Initialize the LLM with structured output
     llm = ChatOpenAI(
         model="gpt-4o-mini",
         temperature=0.1
     ).with_structured_output(ReferenceMaterial)
 
-    # Create a simple prompt
     prompt = ChatPromptTemplate.from_messages([
-        ("system", "You are an expert career analyst. Analyze the provided information to generate a structured analysis."),
+        ("system", """You are an expert at identifying compelling personal narratives 
+        and motivational elements from people's backgrounds. Focus on finding:
+        1. Authentic stories that demonstrate growth and resilience
+        2. Genuine sources of pride and motivation
+        3. Clear connections between past experiences and future aspirations
+        4. Unique elements that make their story compelling
+        
+        Your output MUST include:
+        - A core narrative about their journey
+        - Key achievements that showcase their potential
+        - Specific challenges they've overcome
+        - Clear connections between their background and target role
+        - Values demonstrated through their experiences"""),
         ("human", """
-        Resume: {resume}
-        Personal Info: {personal}
-        Job Description: {job}
+        Analyze this person's background to identify elements for a motivational speech:
+
+        Resume Content:
+        {resume}
+
+        Additional Personal Information:
+        {personal}
+
+        Target Position:
+        {job}
+
+        Provide a complete analysis including:
+        1. Core narrative about their journey
+        2. Key achievements
+        3. Challenges overcome
+        4. IMPORTANT: Specific connections between their background and target role
+        5. Values demonstrated through their experiences
         """)
     ])
 
-    # Get structured output directly
     reference_material = llm.invoke(prompt.format_messages(
-        resume=interview_state.user_inital_input.resume_text,
-        personal=interview_state.user_inital_input.personal_text or "",
-        job=interview_state.user_inital_input.job_text or ""
+        resume=interview_state.user_initial_input.resume_text,
+        personal=interview_state.user_initial_input.personal_text or "",
+        job=interview_state.user_initial_input.job_text or ""
     ))
 
-    # Convert ReferenceMaterial instance to a dictionary if needed
     if isinstance(reference_material, ReferenceMaterial):
-        reference_material = reference_material.model_dump()
+        interview_state.reference_material = reference_material
+    else:
+        interview_state.reference_material = ReferenceMaterial(**reference_material)
+
+    return interview_state
+
+def generate_questions_node(interview_state: InterviewState) -> InterviewState:
+    """
+    Generates questions and manages the question history.
+    """
+    llm = ChatOpenAI(
+        model="gpt-4o-mini",
+        temperature=0.35
+    ).with_structured_output(QuestionList)
+
+    # Get existing question texts to avoid duplicates
+    existing_questions = set()
+    if interview_state.qa_history is None:
+        interview_state.qa_history = QuestionList(questions=[])
     
-    # Update state with reference material only
-    interview_state.reference_material = reference_material
+    for q in interview_state.qa_history.questions:
+        existing_questions.add(q.question_text)
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", """Generate 2-3 focused questions that reveal what motivates 
+        this person. Each question should have 3 distinct choices."""),
+        ("human", """
+        Reference Material:
+        {reference_material}
+
+        Previous Questions Asked:
+        {previous_questions}
+
+        Create new questions that:
+        - Are different from previous questions
+        - Focus on motivation and confidence
+        - Connect to their background
+        """)
+    ])
+
+    new_questions = llm.invoke(prompt.format_messages(
+        reference_material=interview_state.reference_material,
+        previous_questions="\n".join([
+            f"Q: {q.question_text}" 
+            for q in (interview_state.qa_history.questions or [])
+        ])
+    ))
+
+    # Filter out any duplicate questions and append new ones
+    unique_new_questions = [
+        q for q in new_questions.questions
+        if q.question_text not in existing_questions
+    ]
+
+    # Update qa_history, initializing if None
+    if interview_state.qa_history is None:
+        interview_state.qa_history = None
+    interview_state.qa_history.questions.extend(unique_new_questions)
 
     return interview_state
+
+def generate_transcript_node(interview_state: InterviewState, speaker_profile: dict) -> InterviewState:
+    """
+    Generates a concise, TTS-friendly motivational speech.
+    """
+    llm = ChatOpenAI(
+        model="gpt-4o-mini",
+        temperature=0.6
+    ).with_structured_output(HypeCastTranscript)
+
+    prompt = ChatPromptTemplate.from_messages([
+    ("system", f"""You are speaking directly TO the candidate about why they should be excited about THIS specific opportunity.
+
+    Adopt these speaking patterns:
+    {speaker_profile['signature_language_patterns']}
+    
+    Follow this message structure:
+    {speaker_profile['core_message_structure']}
+
+    Essential Rules:
+    - Speak directly TO them ("you" and "your")
+    - Connect THEIR specific experiences to the role's requirements
+    - Highlight where their background perfectly matches the opportunity
+    - Build excitement about how they're already prepared for this role
+    - Keep it natural and conversational
+    - Limit to 2 minutes (about 250-300 words)
+    - Use only periods and commas for punctuation
+    
+    Absolutely Avoid:
+    - Generic motivation without specific connections
+    - Any personal stories from you
+    - Markdown or formatting
+    - Line breaks within sentences
+    - Speaking as if you are them
+    - Audience-style questions
+    - Any text not meant to be spoken
+
+    Remember: Your goal is to make them see how perfectly their experience 
+    aligns with this role and why they should be excited about this specific 
+    opportunity."""),
+    ("human", """
+    Their Background and Experience:
+    {reference_material}
+
+    Their Motivations and Goals:
+    {qa_history}
+
+    Create an energetic, personal talk that shows them why they're perfect for this role.
+    """)
+    ])
+
+    transcript = llm.invoke(prompt.format_messages(
+        reference_material=interview_state.reference_material,
+        qa_history=interview_state.qa_history
+    ))
+
+    interview_state.transcript = transcript
+
+    return interview_state
+
+# def build_reference_material_node(interview_state: InterviewState) -> InterviewState:
+#     """
+#     Analyzes candidate background and job requirements to generate structured reference material.
+#     """
+
+#     # Initialize the LLM with structured output
+#     llm = ChatOpenAI(
+#         model="gpt-4o-mini",
+#         temperature=0.1
+#     ).with_structured_output(ReferenceMaterial)
+
+#     # Create a simple prompt
+#     prompt = ChatPromptTemplate.from_messages([
+#         ("system", "You are an expert career analyst. Analyze the provided information to generate a structured analysis."),
+#         ("human", """
+#         Resume: {resume}
+#         Personal Info: {personal}
+#         Job Description: {job}
+#         """)
+#     ])
+
+#     # Get structured output directly
+#     reference_material = llm.invoke(prompt.format_messages(
+#         resume=interview_state.user_inital_input.resume_text,
+#         personal=interview_state.user_inital_input.personal_text or "",
+#         job=interview_state.user_inital_input.job_text or ""
+#     ))
+
+#     # Convert ReferenceMaterial instance to a dictionary if needed
+#     if isinstance(reference_material, ReferenceMaterial):
+#         reference_material = reference_material.model_dump()
+    
+#     # Update state with reference material only
+#     interview_state.reference_material = reference_material
+
+#     return interview_state
+
+# def generate_questions_node(interview_state: InterviewState) -> InterviewState:
+#     """
+#     Generates relevant interview questions based on the candidate's background and previous Q&A history,
+#     along with generated answers in case the user doesn't respond.
+#     """
+
+#     # Initialize the LLM with structured output
+#     llm = ChatOpenAI(
+#         model="gpt-4o-mini",
+#         temperature=0.35
+#     ).with_structured_output(QAPair)
+
+#     # Build context about previous questions asked
+#     previous_qa_context = ""
+#     if interview_state.qa_history:
+#         previous_qa_context = "\nPreviously asked questions and answers:\n"
+#         for qa in interview_state.qa_history:
+#             previous_qa_context += f"Q: {qa.question}\nA: {qa.answer}\n"
+
+#     # Create a prompt for generating questions and answers
+#     prompt = ChatPromptTemplate.from_messages([
+#         ("system", "You are an enthusiastic technical recruiter. Generate relevant interview questions that have not been asked before, along with a suggested answer."),
+#         ("human", """
+#         Use the following reference material to inform your question:
+#         {reference_material}
+
+#         {previous_qa_context}
+
+#         Please generate new questions that have not been asked yet, and provide a suggested answer for each question.
+#         """)
+#     ])
+
+#     # Get structured output directly
+#     question_pair = llm.invoke(prompt.format_messages(
+#         reference_material=interview_state.reference_material,
+#         previous_qa_context=previous_qa_context
+#     ))
+
+#     # Convert QAPair instance to a dictionary if needed
+#     if isinstance(question_pair, QAPair):
+#         question_pair = question_pair.model_dump()
+
+#     # Append the new QAPair to the QA history
+#     interview_state.qa_history.append(question_pair)
+
+#     return interview_state
+
+# def generate_transcript_node(interview_state: InterviewState, speaker_profile: dict) -> InterviewState:
+#     """
+#     Generates a high-energy podcast transcript based on the candidate's background,
+#     previous Q&A history, and motivational speaking style.
+#     """
+
+#     # Initialize the LLM with structured output
+#     llm = ChatOpenAI(
+#         model="gpt-4o-mini",
+#         temperature=0.6
+#     ).with_structured_output(HypeCastTranscript)  # Expecting a string output for the transcript
+
+#     # Convert the speaker profile dictionary to a string
+#     speaker_profile_str = "\n".join(f"{key}: {value.strip()}" for key, value in speaker_profile.items())
+
+#     # Create a prompt for generating the transcript
+#     prompt = ChatPromptTemplate.from_messages([
+#         ("system", f"""You are an AI simulating a motivational speaker delivering a one-on-one motivational talk.
+#             Use the following profile to guide your communication style:
+#             \n{speaker_profile_str}
+            
+#             CORE RULES:
+#             1. Address the listener (candidate) directly as "you" throughout
+#             2. Never narrate about the candidate in third person
+#             3. Never address an imaginary audience
+#             4. Maintain an intimate, personal conversation
+#             5. Use the reference material to inform your motivation, not to tell their story back to them
+#             6. NEVER include structural headers or section markers
+#             7. NEVER use formatting markers like [INTRO], [PROBLEM], etc.
+#             8. NEVER use **Speaker:** or similar labels
+#             9. Deliver the speech as pure conversational text
+#             10. Only use bold (**) for occasional emphasis of key words, not sections
+
+#             SPEAKING GUIDELINES:
+#             - CORRECT: "When you took on that challenging project - that moment when you had to step up..."
+#             - CORRECT: "Your unique background, the way you've combined different experiences - that's what makes you special..."
+#             - INCORRECT: "[INTRO] Speaker: Let me tell you..."
+#             - INCORRECT: "**Section 1:** Your journey..."
+#             - INCORRECT: "[PROBLEM IDENTIFICATION]"
+
+#             STRUCTURE:
+#             The speech should flow naturally without visible structure markers, transitioning smoothly between:
+#             1. Direct acknowledgment
+#             2. Personal connection
+#             3. Building intensity
+#             4. Call to action
+
+#             TONE:
+#             - Intimate and personal, as if speaking one-on-one
+#             - High energy but focused entirely on the individual
+#             - Draw directly from their experiences to build motivation
+#             - End with a specific call to action about their current opportunity
+
+#             The speaker should deliver a continuous, uninterrupted flow of motivational speech without any formatting or structural markers.
+#             """),
+#         ("human", """
+#         REFERENCE_MATERIAL: {reference_material}
+#         QA_HISTORY: {qa_history}
+
+#         Please generate a transcript using the provided reference material and QA history.
+#         """)
+#     ])
+#     print(f"\n\n prompt: {prompt} \n\n")
+#     # Get structured output directly
+#     transcript = llm.invoke(prompt.format_messages(
+#         reference_material=interview_state.reference_material,
+#         qa_history=interview_state.qa_history
+#     ))
+
+#     # Update the state with the generated transcript
+#     interview_state.transcript = transcript
+
+#     return interview_state
+
+async def text_to_speech_node(interview_state: InterviewState) -> InterviewState:
+    """
+    Converts the generated transcript to speech using LMNT API.
+    This node should be executed after the transcript generation.
+    """
+    if not interview_state.transcript or not interview_state.transcript.content:
+        print("No transcript found to convert to speech")
+        return interview_state
+    
+    try:
+        async with Speech(os.getenv('LMNT_API_KEY')) as s:
+            synthesize = await s.synthesize(
+                text=interview_state.transcript.content,
+                voice='a84f1be9-3db1-4a83-8d9b-1b8b7357d52d',  # Example voice ID
+                language='en',
+                format='mp3'
+            )
+            
+            # Create output filename using timestamp
+            timestamp = int(time.time())
+            output_filename = f"hype_cast_{timestamp}.mp3"
+            
+            # Write the audio data
+            with open(output_filename, 'wb') as f:
+                f.write(synthesize)
+            
+            # Store the audio file path in the interview state
+            interview_state.audio_file_path = output_filename
+            print(f'Audio saved to {output_filename}')
+            
+    except Exception as e:
+        print(f"Error in text-to-speech conversion: {str(e)}")
+        interview_state.audio_file_path = None
+        
+    return interview_state
+
+def run_text_to_speech_node(interview_state: InterviewState) -> InterviewState:
+    """
+    Synchronous wrapper for the async text_to_speech_node.
+    This allows the node to be used in the same way as other nodes in the pipeline.
+    """
+    return asyncio.run(text_to_speech_node(interview_state))
+

hype_pack/utils/speaker_profiles.py

@@ -0,0 +1,124 @@
+tony_robbins = {
+    "core_message_structure": """
+    - Problem identification → Personal story → Universal connection → Solution → Action steps
+    - Uses progressive intensity building through repetition
+    - Creates emotional peaks followed by practical solutions
+    """,
+
+    "engagement_questions": """
+    - How many of you have ever...?
+    - What would happen if...?
+    - Who here is ready to...?
+    - What's been stopping you from...?
+    - If you could change one thing right now...
+    """,
+
+    "signature_language_patterns": """
+    - Uses "state" language (In a beautiful/resourceful/powerful state)
+    - Time urgency phrases (Right now!, In this moment, The time is now)
+    - Certainty phrases (I know without a doubt, I promise you this)
+    - Action commands (Stand up!, Raise your hand if, Say yes!)
+    """,
+
+    "story_framework": """
+    - Opens with tension point
+    - Describes emotional state vividly
+    - Includes specific details about the moment of change
+    - Connects personal breakthrough to universal truth
+    - Ends with actionable insight
+    """
+}
+
+les_brown = {
+    "core_message_structure": """
+    - Acknowledgment of current pain → Personal story → Possibility → Call to action
+    - Uses "You have greatness within you" as recurring theme
+    - Builds through emotional crescendos
+    """,
+    
+    "engagement_questions": """
+    - Can you say that with me?
+    - How many of you know what I'm talking about?
+    - Who feels me on this?
+    - What would your life be like if...?
+    """,
+    
+    "signature_language_patterns": """
+    - Listen to me carefully...
+    - You don't have to be great to get started...
+    - Someone is waiting for you to...
+    - It's possible!
+    - That's what I'm talking about!
+    """,
+    
+    "story_framework": """
+    - Starts with vulnerability
+    - Incorporates dialogue (especially with his mother)
+    - Uses repetition of key phrases
+    - Builds to emotional revelation
+    - Connects to immediate action step
+    """
+}
+
+eric_thomas = {
+    "core_message_structure": """
+    - Reality check → Challenge → Story → Higher standard → Call to action
+    - Uses contrast between current reality and potential
+    - Builds intensity through repetition and volume
+    """,
+    
+    "engagement_questions": """
+    - Do you want it as bad as you want to breathe?
+    - What's your why?
+    - How bad do you want it?
+    - Are you ready to sacrifice?
+    """,
+
+    "signature_language_patterns": """
+    - When you want to succeed as bad as...
+    - I'm here to tell you...
+    - Average is over!
+    - You still ain't gonna get it because...
+    - I'm doing this while you're sleeping!
+    """,
+
+    "story_framework": """
+    - Uses personal hardship as foundation
+    - Incorporates modern cultural references
+    - Builds through progressive intensity
+    - Ends with direct challenge
+    """
+}
+
+simon_sinek = {
+    "core_message_structure": """
+    - Why → How → What framework
+    - Uses circular reasoning to reinforce main point
+    - Builds through logical progression
+    - Ends with call to leadership
+    """,
+
+    "engagement_questions": """
+    - What's your why?
+    - Imagine if...
+    - How many of you have experienced...?
+    - What would happen if we...?
+    - Why do you do what you do?
+    """,
+
+    "signature_language_patterns": """
+    - The goal is not to...
+    - Here's the thing...
+    - People don't buy what you do...
+    - Let me give you an example...
+    - The reason is simple...
+    """,
+
+    "story_framework": """
+    - Starts with counterintuitive observation
+    - Uses business case studies
+    - Connects seemingly unrelated concepts
+    - Builds through logical progression
+    - Ends with universal principle
+    """
+}

hype_pack/utils/state.py

@@ -1,44 +1,140 @@
-from pydantic import BaseModel, Field
-from typing import List, Optional
+from pydantic import BaseModel, Field, conlist
+from langchain_core.messages import BaseMessage
+from langgraph.graph.message import add_messages
+from typing import List, Optional, Sequence, Annotated, Dict
 
-class ReferenceMaterial(BaseModel):
-    """Structured analysis of candidate background and target position."""
-    
-    personal_history_summary: str = Field(
-        description="Summary of candidate's career background and key achievements"
+
+class InitialInput(BaseModel):
+    """Raw input from the user."""
+    resume_text: str = Field(default="", description="Raw text extracted from the resume")
+    personal_text: Optional[str] = Field(default=None, description="Additional personal information provided by the user")
+    job_text: Optional[str] = Field(default=None, description="Job description or position-related text")
+
+### These are classes for the build_reference_material_node
+
+class PersonalStory(BaseModel):
+    """Key moments that can be used as storytelling elements"""
+    challenge: str = Field(description="Specific challenge or obstacle faced")
+    action: str = Field(description="How they addressed the challenge")
+    result: str = Field(description="Outcome and impact of their actions")
+    lessons_learned: str = Field(description="Key takeaways from this experience")
+
+
+class MotivationalElements(BaseModel):
+    """Core elements that drive the person"""
+    key_values: List[str] = Field(
+        description="Personal and professional values demonstrated in their history"
     )
-    
-    aspiring_position_summary: str = Field(
-        description="Overview of the target role and its key requirements"
+    proud_moments: List[str] = Field(
+        description="Achievements they speak about with genuine enthusiasm"
     )
-    
-    personal_focus_points: List[str] = Field(
+    impact_areas: List[str] = Field(
+        description="Areas where they've made meaningful differences"
+    )
+
+class RoleConnection(BaseModel):
+    """Structured connection between experience and target role"""
+    experience: str = Field(description="Relevant past experience")
+    role_requirement: str = Field(description="Matching requirement in target role")
+    strength_level: str = Field(description="How strongly this experience matches")
+
+class ReferenceMaterial(BaseModel):
+    """Essential elements for creating a motivational speech"""
+
+    core_narrative: str = Field(
+        description="The main theme that emerges from their background and aspirations"
+    )
+
+    compelling_stories: List[PersonalStory] = Field(
         default_factory=list,
-        description="Key points highlighting candidate's relevant experiences and skills"
+        description="Key stories that can be used to illustrate their journey"
+    )
+
+    motivation_profile: MotivationalElements = Field(
+        description="Elements that genuinely motivate the person"
     )
     
-    aspiring_position_focus_points: List[str] = Field(
+    role_summary: str = Field(
+        description="A summary of the target role and its key requirements"
+    )
+
+
+    target_role_connections: List[RoleConnection] = Field(
         default_factory=list,
-        description="Essential requirements and expectations of the target role"
+        description="Clear connections between their experiences and the target role"
     )
 
-class QAPair(BaseModel):
-    """Individual question-answer interaction during the interview process."""
+    authenticity_markers: List[str] = Field(
+        description="Genuine aspects of their personality and experience that make their story unique"
+    )
     
-    question_id: int = Field(description="Unique identifier for the Q&A pair")
-    question: str = Field(description="The question asked")
-    answer: Optional[str] = Field(default=None, description="The generated or provided answer")
     
-class InitialInput(BaseModel):
-    """Raw input from the user."""
-    resume_text: str = Field(default="", description="Raw text extracted from the resume")
-    personal_text: Optional[str] = Field(default=None, description="Additional personal information provided by the user")
-    job_text: Optional[str] = Field(default=None, description="Job description or position-related text")
+# class ReferenceMaterial(BaseModel):
+#     """Structured analysis of candidate background and target position."""
+    
+#     personal_history_summary: str = Field(
+#         description="Summary of candidate's career background and key achievements"
+#     )
+    
+#     aspiring_position_summary: str = Field(
+#         description="Overview of the target role and its key requirements"
+#     )
+    
+#     personal_focus_points: List[str] = Field(
+#         default_factory=list,
+#         description="Key points highlighting candidate's relevant experiences and skills"
+#     )
+    
+#     aspiring_position_focus_points: List[str] = Field(
+#         default_factory=list,
+#         description="Essential requirements and expectations of the target role"
+#     )
 
+### These are the classes for the generate_questions_node
+
+class AnswerChoice(BaseModel):
+    """Single answer choice for a question"""
+    text: str = Field(description="The answer option text")
+    category: str = Field(description="Simple category this answer aligns with")
+
+class Question(BaseModel):
+    """Question with multiple choice options"""
+    question_text: str = Field(description="The main question to be asked")
+    context: str = Field(description="Brief context from their background")
+    choices: Annotated[List[AnswerChoice], 
+            conlist(AnswerChoice, min_length=3, max_length=3)
+        ] = Field(description="Three possible answer choices")
+    user_answer: str = Field(description="The user's answer to the question", default="")
+
+# Make sure Question is properly defined as a Pydantic model
+class QuestionList(BaseModel):
+    questions: List[Question]
+
+# class QAPair(BaseModel):
+#     """Individual question-answer interaction during the interview process."""
+    
+#     question_id: int = Field(description="Unique identifier for the Q&A pair")
+#     question: str = Field(description="The question asked")
+#     answer: Optional[str] = Field(default=None, description="The generated or provided answer")
+
+## These are used for the transcript generation node
+
+class HypeCastTranscript(BaseModel):
+    """Motivational speech transcript"""
+    content: str = Field(
+        description="The complete motivational speech as a single flowing conversation"
+    )
+
+
+### This is the main state class
 class InterviewState(BaseModel):
     """Current state of the interview process."""
-    user_inital_input: InitialInput
+    user_initial_input: InitialInput
     reference_material: Optional[ReferenceMaterial] = None
-    qa_history: List[QAPair] = Field(default_factory=list)
-    message_history: List[str] = Field(default_factory=list)  # Consider using specific message types if applicable
-    transcript: str = Field(default="", description="Generated podcast transcript as a single string")
+    qa_history: Optional[QuestionList] = None
+    transcript: Optional[HypeCastTranscript] = None
+    messages: Annotated[Sequence[BaseMessage], add_messages] = []  # Add this line
+    audio_file_path: str | None = None
+
+    class Config:
+        arbitrary_types_allowed = True  # Enable arbitrary types for BaseMessage

pyproject.toml

@@ -5,24 +5,30 @@ description = "AI-powered career matching system"
 authors = ["Leo Walker <leowalker89@gmail.com>"]
 
 [tool.poetry.dependencies]
-python = ">=3.9,<3.12"
+python = ">3.9.7,<3.12"
 langchain = ">=0.3.0,<0.4.0"
 langchain-openai = ">=0.2.0"
 langchain-anthropic = ">=0.2.0,<0.3.0"
 langchain-google-genai = ">=0.0.5"
 langchain-community = ">=0.3.0,<0.4.0"  
+langgraph = "*"
 pypdf = "^3.17.1"
 pydantic = ">=2.0.0,<3.0.0"
 python-dotenv = "^1.0.0"
 openai = ">=1.6.1"
 lmnt = "^0.1.0"
 pydub = "^0.25.1"
+PyPDF2 = "*" 
+streamlit = "^1.40.1"
 
 
 [tool.poetry.group.dev.dependencies]
 ipykernel = "^6.29.5"
 notebook = "^7.2.2"
 
+[tool.poetry.scripts]
+streamlit = "streamlit.cli:main"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"