Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

.gitignore

@@ -0,0 +1,60 @@
+instruction.md
+.env
+*.pyc
+.langchain.db
+*.db
+.gradio/*
+.venv/*
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Gradio
+.gradio/
+flagged/
+
+# Project specific
+.env
+.langchain.db
+cache/
+cache/*.db
+config/credentials.yaml
+
+# Data files
+data/*.mp3
+data/*.wav
+data/*.aac
+data/*.ogg
+data/*.flac
+!data/CBT Role-Play.mp3  # Include our sample audio file
+
+# Logs
+*.log

README.md

@@ -1,12 +1,100 @@
 ---
 title: TherapyNote
-emoji: 📊
-colorFrom: pink
-colorTo: indigo
+app_file: app.py
 sdk: gradio
 sdk_version: 5.9.0
-app_file: app.py
-pinned: false
+organization: pxpab
 ---
+# Therapy Session Analysis Pipeline
+
+A Python project that downloads YouTube therapy session captions and extracts structured information using LLMs, LangChain, and LangGraph.
+
+## Features
+
+- Downloads captions from YouTube therapy sessions
+- Extracts structured information using LLMs and LangChain
+- Supports multiple note formats (SOAP, DAP, BIRP, etc.)
+- Uses LangGraph for data extraction workflows
+- Manages prompts in a dedicated "langhub" directory
+- Integrates with LangSmith for conversation and run logging
+
+## Prerequisites
+
+- Python 3.9+
+- uv package manager
+- OpenAI API key
+- LangChain API key (for logging)
+
+## Installation
+
+1. Clone the repository:
+```bash
+git clone https://github.com/yourusername/therapy-session-analysis.git
+cd therapy-session-analysis
+```
+
+2. Install dependencies using uv:
+```bash
+uv pip install -r requirements.txt
+```
+
+3. Set up environment variables:
+```bash
+export OPENAI_API_KEY="your-openai-key"
+export LANGCHAIN_API_KEY="your-langchain-key"
+export LANGCHAIN_TRACING_V2="true"
+```
+
+## Project Structure
+
+```
+project/
+├── config/
+│   ├── __init__.py
+│   └── settings.py
+├── langhub/
+│   ├── __init__.py
+│   └── prompts/
+│       ├── __init__.py
+│       └── therapy_extraction_prompt.yaml
+├── forms/
+│   ├── __init__.py
+│   └── schemas.py
+├── utils/
+│   ├── __init__.py
+│   ├── youtube.py
+│   └── text_processing.py
+├── models/
+│   ├── __init__.py
+│   └── llm_provider.py
+├── main.py
+├── requirements.txt
+└── README.md
+```
+
+## Usage
+
+Run the main script:
+```bash
+python main.py
+```
+
+## Note Formats
+
+The system supports multiple therapy note formats:
+- SOAP (Subjective, Objective, Assessment, Plan)
+- DAP (Data, Assessment, Plan)
+- BIRP (Behavior, Intervention, Response, Plan)
+- And more...
+
+## Contributing
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This project is licensed under the MIT License - see the LICENSE file for details. 

app.py

@@ -0,0 +1,352 @@
+from __future__ import annotations
+import os
+from pathlib import Path
+import yaml
+import gradio as gr
+from typing import Optional
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage, SystemMessage
+
+from config.settings import settings
+from forms.schemas import (
+    SOAPNote, DAPNote, BIRPNote, PIRPNote, GIRPNote, SIRPNote,
+    FAIRFDARPNote, DARENote, PIENote, SOAPIERNote, SOAPIENote,
+    POMRNote, NarrativeNote, CBENote, SBARNote
+)
+from utils.youtube import download_transcript
+from utils.youtube import extract_youtube_video_id
+from utils.text_processing import chunk_text
+from utils.audio import transcribe_audio
+from models.llm_provider import get_llm, get_model_identifier
+from utils.cache import CacheManager
+from config.auth import load_auth_credentials
+
+# Dictionary mapping form types to their schemas
+FORM_SCHEMAS = {
+    "SOAP": SOAPNote,
+    "DAP": DAPNote,
+    "BIRP": BIRPNote,
+    "PIRP": PIRPNote,
+    "GIRP": GIRPNote,
+    "SIRP": SIRPNote,
+    "FAIR/F-DARP": FAIRFDARPNote,
+    "DARE": DARENote,
+    "PIE": PIENote,
+    "SOAPIER": SOAPIERNote,
+    "SOAPIE": SOAPIENote,
+    "POMR": POMRNote,
+    "Narrative": NarrativeNote,
+    "CBE": CBENote,
+    "SBAR": SBARNote,
+}
+
+# Initialize cache manager
+cache_manager = CacheManager()
+
+def load_prompt(note_type: str) -> tuple[str, str]:
+    """Load the prompt template from YAML for the specified note type."""
+    prompt_path = Path("langhub/prompts/therapy_extraction_prompt.yaml")
+    with open(prompt_path, "r") as f:
+        data = yaml.safe_load(f)
+    
+    note_prompts = data.get("prompts", {}).get(note_type.lower())
+    if not note_prompts:
+        raise ValueError(f"No prompt template found for note type: {note_type}")
+    
+    return note_prompts["system"], note_prompts["human"]
+
+def process_input(
+    input_text: str,
+    form_type: str,
+    input_type: str = "text",
+    audio_file: str | None = None,
+    force_refresh: bool = False
+) -> str:
+    """Process input (text, YouTube URL, or audio) and generate notes."""
+    try:
+        # Get transcript based on input type
+        if input_type == "audio" and audio_file:
+            print("Processing audio file...")
+            transcript = transcribe_audio(audio_file)
+        elif "youtube.com" in input_text or "youtu.be" in input_text:
+            print(f"Downloading transcript from YouTube...")
+            video_id = extract_youtube_video_id(input_text)
+            
+            # Check cache first
+            if not force_refresh:
+                cached_transcript = cache_manager.get_transcript(video_id)
+                if cached_transcript:
+                    print("Using cached transcript...")
+                    transcript = cached_transcript
+                else:
+                    transcript = download_transcript(input_text)
+                    cache_manager.store_transcript(video_id, transcript)
+            else:
+                transcript = download_transcript(input_text)
+                cache_manager.store_transcript(video_id, transcript)
+        else:
+            print("Using provided text directly...")
+            transcript = input_text
+
+        # Initialize LLM
+        llm = get_llm()
+        model_id = get_model_identifier(llm)
+        
+        # Check extraction cache
+        if not force_refresh:
+            cached_result = cache_manager.get_extraction(
+                transcript,
+                form_type.lower(),
+                model_id
+            )
+            if cached_result:
+                print("Using cached extraction result...")
+                formatted_response = yaml.dump(
+                    cached_result,
+                    default_flow_style=False,
+                    sort_keys=False
+                )
+                return f"## {form_type} Note:\n```yaml\n{formatted_response}\n```"
+        
+        # Get schema for selected form type
+        schema = FORM_SCHEMAS.get(form_type)
+        if not schema:
+            return f"Error: Unsupported form type {form_type}"
+        
+        # Create structured LLM
+        structured_llm = llm.with_structured_output(schema=schema)
+        
+        # Load prompts
+        system_prompt, human_prompt = load_prompt(form_type.lower())
+        
+        # Create prompt template
+        prompt = ChatPromptTemplate.from_messages([
+            ("system", system_prompt),
+            ("human", human_prompt)
+        ])
+        
+        # Process transcript
+        print(f"Generating {form_type} note...")
+        response = structured_llm.invoke(transcript)
+        
+        # Store result in cache
+        result_dict = response.model_dump(exclude_unset=False, exclude_none=False)
+        cache_manager.store_extraction(
+            transcript,
+            form_type.lower(),
+            result_dict,
+            model_id
+        )
+        
+        # Format the response
+        formatted_response = yaml.dump(
+            result_dict,
+            default_flow_style=False,
+            sort_keys=False
+        )
+        
+        return f"## {form_type} Note:\n```yaml\n{formatted_response}\n```"
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def create_ui() -> gr.Blocks:
+    """Create the Gradio interface."""
+    
+    # Load authorized users from config
+    auth = load_auth_credentials()
+    
+    def check_auth(username: str, password: str) -> bool:
+        """Check if username and password are valid."""
+        return username in auth and auth[username] == password
+    
+    with gr.Blocks(title="Therapy Note Generator") as demo:
+        # Login interface
+        with gr.Row():
+            with gr.Column():
+                username = gr.Textbox(label="Username")
+                password = gr.Textbox(label="Password", type="password")
+                login_btn = gr.Button("Login")
+                login_msg = gr.Markdown()
+        
+        # Main interface (initially invisible)
+        with gr.Column(visible=False) as main_interface:
+            gr.Markdown("# Therapy Note Generator")
+            gr.Markdown("""
+            Enter a YouTube URL, paste a transcript directly, or upload an audio file.
+            Select the desired note format and click 'Generate' to create a structured note.
+            """)
+            
+            with gr.Row():
+                with gr.Column():
+                    # Input type selector
+                    input_type = gr.Radio(
+                        choices=["text", "youtube", "audio"],
+                        value="text",
+                        label="Input Type",
+                        info="Choose how you want to provide the therapy session"
+                    )
+                    
+                    # Text input for transcript or YouTube URL
+                    input_text = gr.Textbox(
+                        label="Text Input",
+                        placeholder="Enter transcript or YouTube URL here...",
+                        lines=10,
+                        visible=True
+                    )
+                    
+                    # Audio upload
+                    audio_input = gr.Audio(
+                        label="Audio Input",
+                        type="filepath",
+                        visible=False
+                    )
+                    
+                    # Note format selector
+                    form_type = gr.Dropdown(
+                        choices=list(FORM_SCHEMAS.keys()),
+                        value="SOAP",
+                        label="Note Format"
+                    )
+                    
+                    generate_btn = gr.Button("Generate Note", variant="primary")
+                
+                with gr.Column():
+                    # Transcript output
+                    transcript_output = gr.Textbox(
+                        label="Generated Transcript",
+                        lines=10,
+                        visible=False,
+                        interactive=False
+                    )
+                    # Structured note output
+                    note_output = gr.Markdown(label="Generated Note")
+            
+            # Update visibility based on input type
+            def update_inputs(choice):
+                return {
+                    input_text: gr.update(visible=choice in ["text", "youtube"]),
+                    audio_input: gr.update(visible=choice == "audio"),
+                    transcript_output: gr.update(visible=choice in ["youtube", "audio"])
+                }
+            
+            input_type.change(
+                fn=update_inputs,
+                inputs=input_type,
+                outputs=[input_text, audio_input, transcript_output]
+            )
+            
+            def process_and_show_transcript(
+                input_text: str,
+                form_type: str,
+                input_type: str = "text",
+                audio_file: str | None = None,
+                force_refresh: bool = False
+            ) -> tuple[str, str]:
+                """Process input and return both transcript and structured note."""
+                try:
+                    # Get transcript based on input type
+                    if input_type == "audio" and audio_file:
+                        print("Processing audio file...")
+                        transcript = transcribe_audio(audio_file)
+                    elif "youtube.com" in input_text or "youtu.be" in input_text:
+                        print(f"Downloading transcript from YouTube...")
+                        video_id = extract_youtube_video_id(input_text)
+                        
+                        # Check cache first
+                        if not force_refresh:
+                            cached_transcript = cache_manager.get_transcript(video_id)
+                            if cached_transcript:
+                                print("Using cached transcript...")
+                                transcript = cached_transcript
+                            else:
+                                transcript = download_transcript(input_text)
+                                cache_manager.store_transcript(video_id, transcript)
+                        else:
+                            transcript = download_transcript(input_text)
+                            cache_manager.store_transcript(video_id, transcript)
+                    else:
+                        print("Using provided text directly...")
+                        transcript = input_text
+                        
+                    # Process the transcript to generate the note
+                    note_output = process_input(input_text, form_type, input_type, audio_file, force_refresh)
+                    
+                    return transcript, note_output
+                    
+                except Exception as e:
+                    error_msg = f"Error: {str(e)}"
+                    return error_msg, error_msg
+            
+            # Handle generate button click
+            generate_btn.click(
+                fn=process_and_show_transcript,
+                inputs=[input_text, form_type, input_type, audio_input],
+                outputs=[transcript_output, note_output]
+            )
+            
+            # Example inputs
+            try:
+                with open("data/sample_note.txt", "r") as f:
+                    sample_text = f.read()
+            except FileNotFoundError:
+                sample_text = "Sample therapy session transcript..."
+            
+            gr.Examples(
+                examples=[
+                    # Text example
+                    [sample_text, "SOAP", "text", None],
+                    # YouTube examples
+                    ["https://www.youtube.com/watch?v=KuHLL2AE-SE", "DAP", "youtube", None],
+                    ["https://www.youtube.com/watch?v=jS1KE3_Pqlc", "SOAPIER", "youtube", None],
+                    # Audio example
+                    [None, "BIRP", "audio", "data/CBT Role-Play.mp3"]
+                ],
+                inputs=[input_text, form_type, input_type, audio_input],
+                outputs=[transcript_output, note_output],
+                fn=process_and_show_transcript,
+                cache_examples=False,
+                label="Example Inputs",
+                examples_per_page=4
+            )
+        
+        def login(username: str, password: str):
+            """Handle login and return updates for UI components."""
+            if check_auth(username, password):
+                return [
+                    gr.update(visible=True),  # main_interface
+                    gr.update(value="✅ Login successful!", visible=True),  # login_msg
+                    gr.update(visible=False),  # username
+                    gr.update(visible=False),  # password
+                    gr.update(visible=False),  # login_btn
+                ]
+            else:
+                return [
+                    gr.update(visible=False),  # main_interface
+                    gr.update(value="❌ Invalid credentials", visible=True),  # login_msg
+                    gr.update(),  # username - no change
+                    gr.update(),  # password - no change
+                    gr.update(),  # login_btn - no change
+                ]
+        
+        login_btn.click(
+            fn=login,
+            inputs=[username, password],
+            outputs=[main_interface, login_msg, username, password, login_btn]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    # Clean up any existing Gradio cache
+    cache_manager.cleanup_gradio_cache()
+    
+    demo = create_ui()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True,
+        auth=None  # We're using our own auth system instead of Gradio's
+    ) 

config/__init__.py

@@ -0,0 +1 @@
+# Package initialization 

config/auth.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+import os
+from pathlib import Path
+import yaml
+from typing import Dict
+
+def load_auth_credentials() -> Dict[str, str]:
+    """Load authentication credentials from YAML file."""
+    auth_file = Path("config/credentials.yaml")
+    
+    if not auth_file.exists():
+        # Create default credentials file if it doesn't exist
+        default_auth = {
+            "credentials": {
+                "admin": os.environ.get("ADMIN_PASSWORD", "change_this_password"),
+            }
+        }
+        auth_file.parent.mkdir(parents=True, exist_ok=True)
+        with open(auth_file, "w") as f:
+            yaml.dump(default_auth, f)
+    
+    with open(auth_file, "r") as f:
+        auth_data = yaml.safe_load(f)
+    
+    return auth_data.get("credentials", {}) 

config/settings.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+import os
+from dotenv import load_dotenv
+# Load environment variables from .env file
+load_dotenv()
+
+class Settings:
+    OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+    LANGCHAIN_API_KEY = os.environ.get("LANGCHAIN_API_KEY", "")
+    GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY", "")
+    DEEPGRAM_API_KEY = os.environ.get("DEEPGRAM_API_KEY", "")
+    
+    # Provider can be "openai" or "google_gemini"
+    MODEL_PROVIDER = os.environ.get("MODEL_PROVIDER", "openai") # "openai"
+    
+    # Default model names
+    OPENAI_MODEL_NAME = "gpt-4o-mini"
+    GEMINI_MODEL_NAME = "gemini-2.0-flash-exp"
+
+settings = Settings() 

data/sample_note.txt

@@ -0,0 +1,61 @@
+Client: Jane Doe, a 38-year-old female client who has been attending weekly therapy sessions for generalized anxiety and relationship stress.
+Therapist: Dr. Smith, a licensed clinical psychologist
+Date/Time: October 10, 2023, 2:00 PM - 2:45 PM
+Modality: Video telehealth session (client in private home office, therapist in private office)
+
+Presenting Problem:
+Jane has been experiencing increased anxiety, irritability, and difficulty concentrating on personal and professional tasks. She is concerned about her ability to manage stress related to upcoming changes at work and tension in her relationship with her partner.
+
+Sample Transcript & Observations:
+
+2:00 PM - 2:05 PM (Check-in & Rapport Building)
+	•	Therapist: “Hi Jane, it’s good to see you again. How have you been since our last session?”
+	•	Client (Jane): “I’ve felt pretty overwhelmed this past week. My workload at the office nearly doubled, and my partner and I had a few arguments about household responsibilities.”
+
+Therapist’s Notes (Not said aloud): Jane appears somewhat tired; she’s rubbing her temples and has a tense expression. She’s making consistent eye contact but is fidgeting with a pen.
+
+2:05 PM - 2:15 PM (Exploration of Symptoms)
+	•	Therapist: “You mentioned feeling overwhelmed. Can you tell me more about what’s been making you feel that way?”
+	•	Client: “At work, I’m worried I can’t keep up. My manager just assigned three new projects. I’m not sleeping well because I’m anxious about meeting deadlines. I wake up around 4:00 AM every day, heart racing.”
+	•	Therapist: “You mentioned last session that you were using some deep breathing techniques. How has that been going?”
+	•	Client: “I tried once this week, but I felt too restless. I ended up just scrolling through my phone instead, which probably made it worse.”
+
+Therapist’s Notes: Jane reports continued anxiety, difficulty sleeping (waking early and feeling restless), and shows signs of muscle tension (clenched jaw, rubbing neck).
+
+2:15 PM - 2:25 PM (Discussing Relationship Stress)
+	•	Therapist: “You said you had a few arguments with your partner. Can you share what led to those conflicts?”
+	•	Client: “We’ve been arguing about chores and who’s responsible for what. I feel like I’m doing most of the housework. My partner says I’m too critical and not asking for help directly. I guess I’m not communicating well.”
+	•	Therapist: “Have you tried implementing any of the communication strategies we discussed last time, like using ‘I’ statements or scheduling a set time to talk about chores?”
+	•	Client: “I tried once, but it felt forced. I ended up just complaining about how stressed I am. I know that didn’t help.”
+
+Therapist’s Notes: Jane acknowledges difficulty implementing previously discussed communication strategies and expresses guilt and frustration about these interactions.
+
+2:25 PM - 2:35 PM (Coping Strategies & Goals)
+	•	Therapist: “It sounds like the stress at work and home is contributing to your anxiety. Let’s revisit some coping techniques. We talked about structured problem-solving and brief relaxation exercises. Are there any moments during the day you could schedule a short break to practice deep breathing or a quick mindfulness exercise?”
+	•	Client: “I think I could try taking a five-minute break mid-morning. Maybe stepping away from my desk and doing some guided breathing could help.”
+	•	Therapist: “Great. Let’s also consider a small goal for communication at home. Perhaps one evening this week, you could let your partner know when you’re feeling overwhelmed before it escalates. You could say, ‘I’m feeling anxious about work and need a few minutes to gather my thoughts.’”
+	•	Client: “I can try that. I don’t want to keep arguing. I want to feel more in control of these situations.”
+
+Therapist’s Notes: Jane is willing to identify a concrete step: one structured break during work and one proactive communication attempt at home. She appears motivated yet still uncertain.
+
+2:35 PM - 2:40 PM (Review of Mood & Safety)
+	•	Therapist: “On a scale of 0-10, how would you rate your anxiety right now?”
+	•	Client: “Maybe a 6. It was about an 8 earlier in the week.”
+	•	Therapist: “Any thoughts of self-harm or harm to others since we last spoke?”
+	•	Client: “No, I’ve had no suicidal thoughts. It’s just stress and worry, not that kind of feeling.”
+	•	Therapist: “Okay, that’s good to know. Are you still taking your medication as prescribed by your psychiatrist?”
+	•	Client: “Yes, I’ve been consistent with my SSRI. I think it helps a bit.”
+
+Therapist’s Notes: Jane denies self-harm ideation. Anxiety rating is moderately high but lower than peak for the week.
+
+2:40 PM - 2:45 PM (Session Wrap-Up & Next Steps)
+	•	Therapist: “In our next session, we can check in on how the mid-morning breaks and the proactive communication attempt went. Let’s also consider practicing a brief relaxation exercise together next time.”
+	•	Client: “That sounds good. I’ll try to be more consistent with those breaks and let you know how it goes.”
+	•	Therapist: “Great. See you next week at the same time.”
+	•	Client: “Thank you, see you then.”
+
+Supplementary Data/Measures:
+	•	PHQ-9: Administered at intake, last score was 9 (mild-moderate depression symptoms). Not administered this session but client reports stable mood with primarily anxiety-driven symptoms.
+	•	GAD-7: Last recorded score was 12, suggesting moderate anxiety. Client’s subjective rating today is a 6/10 at session’s end.
+
+No presence of family members noted this session. Client was alone in a private space.

forms/__init__.py

@@ -0,0 +1 @@
+# Package initialization 

forms/schemas.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+from pydantic import BaseModel, Field
+
+from typing import Optional, List
+from pydantic import BaseModel, Field
+
+class SOAPNote(BaseModel):
+    """
+    A SOAP note is structured into four sections: Subjective, Objective, Assessment, and Plan.
+    These fields help track the client's self-reported experiences, observable data, the clinician's assessment, and the future treatment plan.
+    """
+    Subjective: Optional[str] = Field(None, description="Client's self-reported symptoms, emotions, concerns, and relevant personal history.")
+    Objective: Optional[str] = Field(None, description="Observable and measurable data, such as behavior, affect, test results, or vital signs.")
+    Assessment: Optional[str] = Field(None, description="Clinician's interpretation of the subjective and objective data, including diagnosis and progress.")
+    Plan: Optional[str] = Field(None, description="Outline of next steps, changes to treatment, referrals, and any planned interventions.")
+
+class DAPNote(BaseModel):
+    """
+    A DAP note includes Data, Assessment, and Plan. It condenses subjective and objective info into a single 'Data' section.
+    """
+    Data: Optional[str] = Field(None, description="Combined subjective and objective information: client's statements, therapist observations, relevant tests.")
+    Assessment: Optional[str] = Field(None, description="Therapist's interpretation of the data, clinical impressions, and identified issues.")
+    Plan: Optional[str] = Field(None, description="Next steps, goals for future sessions, and recommended interventions or activities.")
+
+class BIRPNote(BaseModel):
+    """
+    A BIRP note includes Behavior, Intervention, Response, and Plan, emphasizing the therapist's interventions and the client's reaction.
+    """
+    Behavior: Optional[str] = Field(None, description="Client's behavior during the session (verbal/non-verbal) and any observations made by the therapist.")
+    Intervention: Optional[str] = Field(None, description="Specific techniques, methods, or therapies used by the clinician during the session.")
+    Response: Optional[str] = Field(None, description="How the client responded to the interventions, including changes in affect, participation, or symptom relief.")
+    Plan: Optional[str] = Field(None, description="Follow-up steps, homework assignments, referrals, or next session focus.")
+
+class PIRPNote(BaseModel):
+    """
+    A PIRP note is Problem, Intervention, Response, and Plan, focusing on a particular client problem.
+    """
+    Problem: Optional[str] = Field(None, description="The client's presenting problem, symptoms, or reason for seeking therapy.")
+    Intervention: Optional[str] = Field(None, description="Actions taken by the therapist to address the identified problem.")
+    Response: Optional[str] = Field(None, description="Client's reaction or changes after the intervention was applied.")
+    Plan: Optional[str] = Field(None, description="Next steps for addressing the problem, including future sessions, techniques, or referrals.")
+
+class GIRPNote(BaseModel):
+    """
+    A GIRP note focuses on Goals, Intervention, Response, and Plan, centering around client-defined goals.
+    """
+    Goals: Optional[str] = Field(None, description="The client's short-term and long-term therapy goals or objectives.")
+    Intervention: Optional[str] = Field(None, description="Therapeutic interventions used to help the client work toward these goals.")
+    Response: Optional[str] = Field(None, description="How the client responded to the interventions and their progress toward goals.")
+    Plan: Optional[str] = Field(None, description="Plan for future sessions, homework, referrals, or adjustments to help achieve goals.")
+
+class SIRPNote(BaseModel):
+    """
+    A SIRP note organizes notes by Situation, Intervention, Response, and Plan, emphasizing the client's current situation.
+    """
+    Situation: Optional[str] = Field(None, description="The client's presenting situation, including current symptoms, concerns, and background info.")
+    Intervention: Optional[str] = Field(None, description="Interventions, assessments, and recommendations made during the session.")
+    Response: Optional[str] = Field(None, description="Client's response to the intervention, observed changes or feedback.")
+    Plan: Optional[str] = Field(None, description="Next steps, follow-up appointments, referrals, and any planned adjustments.")
+
+class FAIRFDARPNote(BaseModel):
+    """
+    A FAIR/F-DARP note includes Focus, Assessment, Intervention, Response (FAIR) 
+    or Focus, Data, Action, Response, Plan (F-DARP). 
+    Here we combine them: Focus, Data, Action, Response, (and optionally Plan).
+    """
+    Focus: Optional[str] = Field(None, description="Focus of the note, such as a nursing diagnosis, event, or primary concern.")
+    Data: Optional[str] = Field(None, description="Subjective and objective data about the client/patient condition.")
+    Action: Optional[str] = Field(None, description="Actions taken by the provider in response to the data (e.g., treatments, education).")
+    Response: Optional[str] = Field(None, description="Client's response to the actions taken.")
+    Plan: Optional[str] = Field(None, description="Future steps or follow-up if using the full F-DARP format.")
+
+class DARENote(BaseModel):
+    """
+    A DARE note stands for Data, Action, Response, Education. Emphasizes client education and their response.
+    """
+    Data: Optional[str] = Field(None, description="Subjective and objective client information and therapist's observations.")
+    Action: Optional[str] = Field(None, description="Specific actions, treatments, or interventions the therapist took.")
+    Response: Optional[str] = Field(None, description="Client's response to those actions, improvements, or changes in symptoms.")
+    Education: Optional[str] = Field(None, description="Education provided to the client about their condition, treatments, or coping strategies.")
+
+class PIENote(BaseModel):
+    """
+    A PIE note: Problem, Intervention, Evaluation. It's similar to PIRP but focuses on evaluating interventions.
+    """
+    Problem: Optional[str] = Field(None, description="Client's identified problem, whether mental health symptom or behavior issue.")
+    Intervention: Optional[str] = Field(None, description="What the therapist did to address the problem (techniques, strategies).")
+    Evaluation: Optional[str] = Field(None, description="How effective the intervention was, changes in the client, and next steps.")
+
+class SOAPIERNote(BaseModel):
+    """
+    A SOAPIER note expands SOAP by adding Intervention, Evaluation, and Revision sections for more comprehensive documentation.
+    """
+    Subjective: Optional[str] = Field(None, description="Client's subjective complaints, feelings, statements.")
+    Objective: Optional[str] = Field(None, description="Observable, measurable data, test results, or observations.")
+    Assessment: Optional[str] = Field(None, description="Therapist's interpretation, diagnosis, or clinical judgment.")
+    Plan: Optional[str] = Field(None, description="Proposed interventions, follow-ups, or referrals.")
+    Intervention: Optional[str] = Field(None, description="Specific interventions implemented during the session.")
+    Evaluation: Optional[str] = Field(None, description="Client's response to interventions and progress made.")
+    Revision: Optional[str] = Field(None, description="Adjustments to the treatment plan based on evaluation.")
+
+class SOAPIENote(BaseModel):
+    """
+    A SOAPIE note is similar to SOAPIER but only adds Intervention and Evaluation to the standard SOAP note.
+    """
+    Subjective: Optional[str] = Field(None, description="Client's self-reported experiences and symptoms.")
+    Objective: Optional[str] = Field(None, description="Observable data and measurable findings.")
+    Assessment: Optional[str] = Field(None, description="Clinician's interpretation and clinical impressions.")
+    Plan: Optional[str] = Field(None, description="Planned interventions, referrals, or changes.")
+    Intervention: Optional[str] = Field(None, description="Interventions used during the session.")
+    Evaluation: Optional[str] = Field(None, description="Client's response to interventions and progress toward goals.")
+
+class POMRNote(BaseModel):
+    """
+    POMR: Problem-Oriented Medical Record. Focuses on organizing data around problems.
+    """
+    Database: Optional[str] = Field(None, description="Patient's history, exam findings, and relevant tests.")
+    ProblemList: Optional[str] = Field(None, description="All identified problems, both active and resolved.")
+    InitialPlan: Optional[str] = Field(None, description="Initial plan to address each problem, including diagnostics or treatments.")
+    ProgressNotes: Optional[str] = Field(None, description="Ongoing progress, changes, and outcomes related to each problem.")
+
+class NarrativeNote(BaseModel):
+    """
+    A Narrative note is a free-text record, providing flexibility for a descriptive, story-like documentation.
+    """
+    Narrative: Optional[str] = Field(None, description="A free-form description of the session, events, observations, and client interactions.")
+
+class CBENote(BaseModel):
+    """
+    CBE: Charting By Exception. Only notes deviations from the norm.
+    """
+    Exceptions: Optional[str] = Field(None, description="Significant changes or unexpected findings from the norm, highlighting what differs.")
+
+class SBARNote(BaseModel):
+    """
+    SBAR: Situation, Background, Assessment, and Recommendation. Used often in quick communication contexts.
+    """
+    Situation: Optional[str] = Field(None, description="Brief description of the patient's current situation or issue.")
+    Background: Optional[str] = Field(None, description="Relevant background information, history, current meds, or past sessions.")
+    Assessment: Optional[str] = Field(None, description="Clinician's assessment of the current condition or problem.")
+    Recommendation: Optional[str] = Field(None, description="Suggested next steps, treatments, referrals, or actions.")
+
+class ExtractedNotes(BaseModel):
+    """Container for multiple note formats."""
+    soap: SOAPNote | None = None
+    dap: DAPNote | None = None
+    birp: BIRPNote | None = None 
+    pirp: PIRPNote | None = None
+    girp: GIRPNote | None = None
+    sirp: SIRPNote | None = None
+    fairfdarp: FAIRFDARPNote | None = None
+    dare: DARENote | None = None
+    pie: PIENote | None = None
+    soapiier: SOAPIERNote | None = None
+    soapiie: SOAPIENote | None = None
+    pomr: POMRNote | None = None
+    narrative: NarrativeNote | None = None
+    cbe: CBENote | None = None
+    sbar: SBARNote | None = None

langhub/__init__.py

@@ -0,0 +1 @@
+# Package initialization 

langhub/prompts/__init__.py

@@ -0,0 +1 @@
+# Package initialization 

langhub/prompts/therapy_extraction_prompt.yaml

@@ -0,0 +1,237 @@
+prompts:
+  soap:
+    system: |
+      You are an expert therapist assistant. Extract a SOAP note from the following therapy session transcript.
+    human: |
+      Please follow the SOAPNote schema strictly:
+      - Subjective: The client's own words about their feelings, symptoms, or concerns.
+      - Objective: The therapist's direct observations, measurable data, or test results.
+      - Assessment: Your clinical interpretation of the client's situation, progress, and any diagnostic impressions.
+      - Plan: The next steps to be taken, including future interventions, referrals, or adjustments in therapy.
+
+      If any of the fields are not mentioned, return them as null.
+
+      Transcript:
+      {text}
+
+  dap:
+    system: |
+      You are an expert therapist assistant. Extract a DAP note from the following therapy session transcript.
+    human: |
+      You are a mental health professional. Based on the transcript, produce a DAP note:
+
+      - Data: Include both subjective (client's words/feelings) and objective (observed behaviors, test results) in a factual manner.
+      - Assessment: Your interpretation, impression, or diagnosis based on the data.
+      - Plan: Outline next steps, goals, or interventions planned.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  birp:
+    system: |
+      You are an expert therapist assistant. Extract a BIRP note from the following therapy session transcript.
+    human: |
+      Please extract a BIRP note following this structure:
+
+      - Behavior: Client's behavior during the session (verbal/non-verbal) and observations.
+      - Intervention: Specific techniques and methods used by the therapist.
+      - Response: How the client responded to interventions.
+      - Plan: Follow-up steps and future recommendations.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  pirp:
+    system: |
+      You are an expert therapist assistant. Extract a PIRP note from the following therapy session transcript.
+    human: |
+      Please extract a PIRP note following this structure:
+
+      - Problem: The client's presenting problem, symptoms, or reason for seeking therapy.
+      - Intervention: Actions taken by the therapist to address the identified problem.
+      - Response: Client's reaction or changes after the intervention was applied.
+      - Plan: Next steps for addressing the problem, including future sessions, techniques, or referrals.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  girp:
+    system: |
+      You are an expert therapist assistant. Extract a GIRP note from the following therapy session transcript.
+    human: |
+      Please extract a GIRP note following this structure:
+
+      - Goals: The client's short-term and long-term therapy goals or objectives.
+      - Intervention: Therapeutic interventions used to help the client work toward these goals.
+      - Response: How the client responded to the interventions and their progress toward goals.
+      - Plan: Plan for future sessions, homework, referrals, or adjustments to help achieve goals.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  sirp:
+    system: |
+      You are an expert therapist assistant. Extract a SIRP note from the following therapy session transcript.
+    human: |
+      Please extract a SIRP note following this structure:
+
+      - Situation: The client's presenting situation, including current symptoms, concerns, and background info.
+      - Intervention: Interventions, assessments, and recommendations made during the session.
+      - Response: Client's response to the intervention, observed changes or feedback.
+      - Plan: Next steps, follow-up appointments, referrals, and any planned adjustments.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  fair_f_darp:
+    system: |
+      You are an expert therapist assistant. Extract a FAIR/F-DARP note from the following therapy session transcript.
+    human: |
+      Please extract a FAIR/F-DARP note following this structure:
+
+      - Focus: Focus of the note, such as a nursing diagnosis, event, or primary concern.
+      - Data: Subjective and objective data about the client/patient condition.
+      - Action: Actions taken by the provider in response to the data.
+      - Response: Client's response to the actions taken.
+      - Plan: Future steps or follow-up if using the full F-DARP format.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  dare:
+    system: |
+      You are an expert therapist assistant. Extract a DARE note from the following therapy session transcript.
+    human: |
+      Please extract a DARE note following this structure:
+
+      - Data: Subjective and objective client information and therapist's observations.
+      - Action: Specific actions, treatments, or interventions the therapist took.
+      - Response: Client's response to those actions, improvements, or changes in symptoms.
+      - Education: Education provided to the client about their condition, treatments, or coping strategies.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  pie:
+    system: |
+      You are an expert therapist assistant. Extract a PIE note from the following therapy session transcript.
+    human: |
+      Please extract a PIE note following this structure:
+
+      - Problem: Client's identified problem, whether mental health symptom or behavior issue.
+      - Intervention: What the therapist did to address the problem (techniques, strategies).
+      - Evaluation: How effective the intervention was, changes in the client, and next steps.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  soapier:
+    system: |
+      You are an expert therapist assistant. Extract a SOAPIER note from the following therapy session transcript.
+    human: |
+      Please extract a SOAPIER note following this structure:
+
+      - Subjective: Client's subjective complaints, feelings, statements.
+      - Objective: Observable, measurable data, test results, or observations.
+      - Assessment: Therapist's interpretation, diagnosis, or clinical judgment.
+      - Plan: Proposed interventions, follow-ups, or referrals.
+      - Intervention: Specific interventions implemented during the session.
+      - Evaluation: Client's response to interventions and progress made.
+      - Revision: Adjustments to the treatment plan based on evaluation.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  soapie:
+    system: |
+      You are an expert therapist assistant. Extract a SOAPIE note from the following therapy session transcript.
+    human: |
+      Please extract a SOAPIE note following this structure:
+
+      - Subjective: Client's self-reported experiences and symptoms.
+      - Objective: Observable data and measurable findings.
+      - Assessment: Clinician's interpretation and clinical impressions.
+      - Plan: Planned interventions, referrals, or changes.
+      - Intervention: Interventions used during the session.
+      - Evaluation: Client's response to interventions and progress toward goals.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  pomr:
+    system: |
+      You are an expert therapist assistant. Extract a POMR note from the following therapy session transcript.
+    human: |
+      Please extract a POMR note following this structure:
+
+      - Database: Patient's history, exam findings, and relevant tests.
+      - ProblemList: All identified problems, both active and resolved.
+      - InitialPlan: Initial plan to address each problem, including diagnostics or treatments.
+      - ProgressNotes: Ongoing progress, changes, and outcomes related to each problem.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  narrative:
+    system: |
+      You are an expert therapist assistant. Extract a Narrative note from the following therapy session transcript.
+    human: |
+      Please extract a Narrative note following this structure:
+
+      - Narrative: A free-form description of the session, events, observations, and client interactions.
+
+      If the section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  cbe:
+    system: |
+      You are an expert therapist assistant. Extract a CBE note from the following therapy session transcript.
+    human: |
+      Please extract a CBE note following this structure:
+
+      - Exceptions: Significant changes or unexpected findings from the norm, highlighting what differs.
+
+      If the section isn't applicable, return it as null.
+
+      Transcript:
+      {text}
+
+  sbar:
+    system: |
+      You are an expert therapist assistant. Extract a SBAR note from the following therapy session transcript.
+    human: |
+      Please extract a SBAR note following this structure:
+
+      - Situation: Brief description of the patient's current situation or issue.
+      - Background: Relevant background information, history, current meds, or past sessions.
+      - Assessment: Clinician's assessment of the current condition or problem.
+      - Recommendation: Suggested next steps, treatments, referrals, or actions.
+
+      If any section isn't applicable, return it as null.
+
+      Transcript:
+      {text}

main.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+import os
+from pathlib import Path
+import yaml
+
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.runnables import RunnableSequence
+from langgraph.prebuilt import ValidationNode
+
+from config.settings import settings
+from forms.schemas import ExtractedNotes, SOAPNote, DAPNote, BIRPNote, PIRPNote, GIRPNote, SIRPNote, FAIRFDARPNote, DARENote, PIENote, SOAPIERNote, SOAPIENote, POMRNote, NarrativeNote, CBENote, SBARNote
+from utils.youtube import download_transcript
+from utils.text_processing import chunk_text
+from models.llm_provider import get_llm
+from langchain.globals import set_llm_cache
+from langchain.cache import SQLiteCache
+
+set_llm_cache(SQLiteCache(database_path=".langchain.db"))
+
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Set environment for LangSmith tracing/logging
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+if settings.LANGCHAIN_API_KEY:
+    os.environ["LANGCHAIN_API_KEY"] = settings.LANGCHAIN_API_KEY
+
+def load_prompt(note_type: str) -> tuple[str, str]:
+    """Load the prompt template from YAML for the specified note type."""
+    prompt_path = Path("langhub/prompts/therapy_extraction_prompt.yaml")
+    with open(prompt_path, "r") as f:
+        data = yaml.safe_load(f)
+    
+    note_prompts = data.get("prompts", {}).get(note_type.lower())
+    if not note_prompts:
+        raise ValueError(f"No prompt template found for note type: {note_type}")
+    
+    return note_prompts["system"], note_prompts["human"]
+
+def create_extraction_chain(note_type: str = "soap") -> RunnableSequence:
+    """Create a chain for extracting structured notes."""
+    print(f"Creating extraction chain for {note_type.upper()} notes...")
+    
+    print("Initializing LLM...")
+    llm = get_llm()
+    
+    print("Setting up schema mapping...")
+    # Select the appropriate schema based on note type
+    schema_map = {
+        "soap": SOAPNote,
+        "dap": DAPNote,
+        "birp": BIRPNote,
+        "birp_raw": BIRPNote,
+        "pirp": PIRPNote,
+        "girp": GIRPNote,
+        "sirp": SIRPNote,
+        "fair_fdarp": FAIRFDARPNote,
+        "dare": DARENote,
+        "pie": PIENote,
+        "soapier": SOAPIERNote,
+        "soapie": SOAPIENote,
+        "pomr": POMRNote,
+        "narrative": NarrativeNote,
+        "cbe": CBENote,
+        "sbar": SBARNote
+    }
+    schema = schema_map.get(note_type.lower())
+
+    if not schema:
+        raise ValueError(f"Unsupported note type: {note_type}")
+    
+    print("Creating structured LLM output...")
+    # Create structured LLM
+    structured_llm = llm.with_structured_output(schema=schema, include_raw=True)
+    
+    print("Loading system prompt...")
+    # Load system prompt and human prompt for the specific note type
+    system_prompt, human_prompt = load_prompt(note_type)
+    
+    print("Creating prompt template...")
+    # Create prompt template
+    prompt_template = ChatPromptTemplate.from_messages([
+        ("system", system_prompt),
+        ("human", human_prompt)
+    ])
+    
+    print("Building extraction chain...")
+    # Create the chain
+    chain = prompt_template | structured_llm
+    
+    print("Extraction chain created successfully")
+    return chain
+
+def process_session(url: str, note_type: str = "soap") -> dict:
+    """Process a single therapy session."""
+    try:
+        # Download transcript
+        print(f"Downloading transcript from {url}...")
+        transcript = download_transcript(url)
+        
+        # Create extraction chain
+        chain = create_extraction_chain(note_type)
+        
+        # Process transcript
+        print("Extracting structured notes...")
+        result = chain.invoke({
+            "note_type": note_type.upper(),
+            "text": transcript
+        })
+        
+        return result.model_dump()
+        
+    except Exception as e:
+        print(f"Error processing session: {str(e)}")
+        return {}
+
+def main():
+    # Example YouTube sessions
+    sessions = [
+        {
+            "title": "CBT Role-Play – Complete Session – Part 6",
+            "url": "https://www.youtube.com/watch?v=KuHLL2AE-SE"
+        },
+        {
+            "title": "CBT Role-Play – Complete Session – Part 7",
+            "url": "https://www.youtube.com/watch?v=jS1KE3_Pqlc"
+        }
+    ]
+    
+    for session in sessions:
+        print(f"\nProcessing session: {session['title']}")
+        
+        # Extract notes in different formats
+        note_types = ["soap", "dap", "birp"]
+        results = {}
+        
+        for note_type in note_types:
+            print(f"\nExtracting {note_type.upper()} notes...")
+            result = process_session(session["url"], note_type)
+            results[note_type] = result
+        
+        # Print results
+        print(f"\nResults for '{session['title']}':")
+        for note_type, notes in results.items():
+            print(f"\n{note_type.upper()} Notes:")
+            print(yaml.dump(notes, default_flow_style=False))
+
+if __name__ == "__main__":
+    main() 

models/__init__.py

@@ -0,0 +1 @@
+# Package initialization 

models/llm_provider.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from config.settings import settings
+from langchain_openai import ChatOpenAI
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+def get_model_identifier(llm) -> str:
+    """Get a unique identifier for the model."""
+    if isinstance(llm, ChatOpenAI):
+        return f"openai-{llm.model_name}"
+    elif isinstance(llm, ChatGoogleGenerativeAI):
+        return f"gemini-{settings.GEMINI_MODEL_NAME}"
+    else:
+        return "unknown-model"
+
+def get_llm(model_name: str | None = None):
+    """
+    Return an LLM instance based on the configured provider.
+    """
+    provider = settings.MODEL_PROVIDER
+
+    if provider == "openai":
+        model_name = model_name or settings.OPENAI_MODEL_NAME
+        if not settings.OPENAI_API_KEY:
+            raise ValueError("OPENAI_API_KEY is not set")
+        llm = ChatOpenAI(
+            model=model_name,
+            openai_api_key=settings.OPENAI_API_KEY,
+            temperature=0,
+        )
+    elif provider == "google_gemini":
+        model_name = model_name or settings.GEMINI_MODEL_NAME
+        if not settings.GOOGLE_API_KEY:
+            raise ValueError("GOOGLE_API_KEY is not set")
+        llm = ChatGoogleGenerativeAI(
+            model=model_name,
+            temperature=0,
+            max_tokens=None,
+            max_retries=2,
+        )
+    else:
+        raise ValueError(f"Unknown model provider: {provider}")
+
+    return llm 

requirements.txt

@@ -0,0 +1,16 @@
+langchain
+langchain-core
+langchain-openai>=0.1.0
+langgraph>=0.1.45
+pydantic>=2.0.0
+openai
+youtube-transcript-api
+pyyaml
+langchain-google-genai 
+python-dotenv
+langchain-community
+gradio>=4.0.0
+google-generativeai>=0.3.0
+pydub
+python-slugify
+deepgram-sdk>=3.0,<4.0

utils/__init__.py

@@ -0,0 +1 @@
+# Package initialization 

utils/audio.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+import os
+from pathlib import Path
+from pydub import AudioSegment
+from utils.transcription import TranscriptionService
+
+# Initialize the transcription service
+transcription_service = TranscriptionService()
+
+def convert_audio_to_wav(audio_path: str | Path) -> str:
+    """Convert uploaded audio to WAV format if needed."""
+    audio_path = Path(audio_path)
+    output_path = audio_path.with_suffix('.wav')
+    
+    if audio_path.suffix.lower() != '.wav':
+        print(f"Converting {audio_path.name} to WAV format...")
+        audio = AudioSegment.from_file(audio_path)
+        audio.export(output_path, format='wav')
+        return str(output_path)
+    
+    return str(audio_path)
+
+def transcribe_audio(audio_path: str | Path) -> str:
+    """
+    Transcribe audio using Deepgram.
+    Supports multiple audio formats, converts to WAV if needed.
+    """
+    try:
+        # Convert to WAV if needed
+        wav_path = convert_audio_to_wav(audio_path)
+        
+        # Transcribe using Deepgram
+        transcript = transcription_service.transcribe_file(wav_path)
+        
+        return transcript
+        
+    except Exception as e:
+        raise Exception(f"Error transcribing audio: {str(e)}")

utils/cache.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+import hashlib
+import json
+import sqlite3
+from pathlib import Path
+from typing import Any
+from datetime import datetime
+
+class CacheManager:
+    def __init__(self, cache_dir: str | Path = "cache"):
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Create SQLite database for structured results
+        self.db_path = self.cache_dir / "extraction_cache.db"
+        self._init_db()
+    
+    def _init_db(self):
+        """Initialize the SQLite database with necessary tables."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS extractions (
+                    input_hash TEXT,
+                    form_type TEXT,
+                    result TEXT,
+                    model_name TEXT,
+                    timestamp DATETIME,
+                    PRIMARY KEY (input_hash, form_type)
+                )
+            """)
+            
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS transcripts (
+                    video_id TEXT PRIMARY KEY,
+                    transcript TEXT,
+                    timestamp DATETIME
+                )
+            """)
+    
+    def _hash_content(self, content: str) -> str:
+        """Generate a stable hash for input content."""
+        return hashlib.sha256(content.encode('utf-8')).hexdigest()
+    
+    def get_transcript(self, video_id: str) -> str | None:
+        """Retrieve a cached transcript if it exists."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                "SELECT transcript FROM transcripts WHERE video_id = ?",
+                (video_id,)
+            )
+            result = cursor.fetchone()
+            return result[0] if result else None
+    
+    def store_transcript(self, video_id: str, transcript: str):
+        """Store a transcript in the cache."""
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO transcripts (video_id, transcript, timestamp)
+                VALUES (?, ?, ?)
+                """,
+                (video_id, transcript, datetime.now())
+            )
+    
+    def get_extraction(
+        self,
+        input_content: str,
+        form_type: str,
+        model_name: str
+    ) -> dict | None:
+        """Retrieve cached extraction results if they exist."""
+        input_hash = self._hash_content(input_content)
+        
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.execute(
+                """
+                SELECT result FROM extractions 
+                WHERE input_hash = ? AND form_type = ? AND model_name = ?
+                """,
+                (input_hash, form_type, model_name)
+            )
+            result = cursor.fetchone()
+            
+            if result:
+                return json.loads(result[0])
+        return None
+    
+    def store_extraction(
+        self,
+        input_content: str,
+        form_type: str,
+        result: dict,
+        model_name: str
+    ):
+        """Store extraction results in the cache."""
+        input_hash = self._hash_content(input_content)
+        
+        with sqlite3.connect(self.db_path) as conn:
+            conn.execute(
+                """
+                INSERT OR REPLACE INTO extractions 
+                (input_hash, form_type, result, model_name, timestamp)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                (
+                    input_hash,
+                    form_type,
+                    json.dumps(result),
+                    model_name,
+                    datetime.now()
+                )
+            )
+    
+    def clear_cache(self, older_than_days: int | None = None):
+        """Clear the cache, optionally only entries older than specified days."""
+        with sqlite3.connect(self.db_path) as conn:
+            if older_than_days is not None:
+                conn.execute(
+                    """
+                    DELETE FROM extractions 
+                    WHERE timestamp < datetime('now', ?)
+                    """,
+                    (f'-{older_than_days} days',)
+                )
+                conn.execute(
+                    """
+                    DELETE FROM transcripts 
+                    WHERE timestamp < datetime('now', ?)
+                    """,
+                    (f'-{older_than_days} days',)
+                )
+            else:
+                conn.execute("DELETE FROM extractions")
+                conn.execute("DELETE FROM transcripts") 
+    
+    def cleanup_gradio_cache(self):
+        """Clean up Gradio's example cache directory."""
+        gradio_cache = Path(".gradio")
+        if gradio_cache.exists():
+            import shutil
+            shutil.rmtree(gradio_cache)
+            print("Cleaned up Gradio cache")

utils/text_processing.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+def chunk_text(text: str, chunk_size: int = 3000) -> list[str]:
+    """
+    Simple utility to chunk text into manageable pieces if needed
+    for long transcripts.
+    """
+    words = text.split()
+    chunks = []
+    for i in range(0, len(words), chunk_size):
+        chunks.append(" ".join(words[i:i+chunk_size]))
+    return chunks 

utils/transcription.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+from pathlib import Path
+import httpx
+from deepgram import (
+    DeepgramClient,
+    DeepgramClientOptions,
+    PrerecordedOptions,
+    FileSource,
+)
+from config.settings import settings
+
+class TranscriptionService:
+    def __init__(self):
+        if not settings.DEEPGRAM_API_KEY:
+            raise ValueError("DEEPGRAM_API_KEY is not set in environment variables")
+        
+        # Initialize Deepgram client with options
+        config = DeepgramClientOptions(
+            verbose=False,  # Set to True for debugging
+        )
+        self.client = DeepgramClient(settings.DEEPGRAM_API_KEY, config)
+        
+    def transcribe_file(self, audio_path: str | Path) -> str:
+        """
+        Transcribe an audio file using Deepgram.
+        
+        Args:
+            audio_path: Path to the audio file
+            
+        Returns:
+            Transcribed text with proper formatting
+        """
+        try:
+            print(f"Transcribing audio file: {audio_path}")
+            
+            # Read file into buffer
+            with open(audio_path, "rb") as file:
+                buffer_data = file.read()
+
+            # Create payload
+            payload: FileSource = {
+                "buffer": buffer_data,
+            }
+            
+            # Configure transcription options
+            options = PrerecordedOptions(
+                model="nova-2",
+                smart_format=True,
+                language="en-US",
+                utterances=True,
+                punctuate=True,
+                diarize=True
+            )
+            
+            # Transcribe with timeout
+            response = self.client.listen.rest.v("1").transcribe_file(
+                payload,
+                options,
+                timeout=httpx.Timeout(300.0, connect=10.0)
+            )
+            
+            # Extract the transcript from the response
+            transcript = response.results.channels[0].alternatives[0].transcript
+            
+            return transcript.strip()
+            
+        except Exception as e:
+            raise Exception(f"Error transcribing with Deepgram: {str(e)}") 

utils/youtube.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+from youtube_transcript_api import YouTubeTranscriptApi
+from urllib.parse import urlparse, parse_qs
+
+def extract_youtube_video_id(url: str) -> str:
+    """Extract the video_id from a YouTube URL."""
+    parsed = urlparse(url)
+    if parsed.hostname in ('www.youtube.com', 'youtube.com'):
+        return parse_qs(parsed.query)['v'][0]
+    elif parsed.hostname == 'youtu.be':
+        return parsed.path.lstrip('/')
+    raise ValueError("Invalid YouTube URL")
+
+def download_transcript(url: str) -> str:
+    """Download the YouTube transcript as a string."""
+    video_id = extract_youtube_video_id(url)
+    print(f"Downloading transcript for video ID: {video_id}")
+    transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+    full_text = " ".join([item['text'] for item in transcript_list])
+    return full_text