Initial commit of AI Doctor App

README.md

@@ -1,12 +1,8 @@
----
-title: AI Doctor
-emoji: 👀
-colorFrom: pink
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.45.0
-app_file: app.py
-pinned: false
----
+# AI Doctor
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+AI-powered health insights in your native language. Upload medical reports for analysis and get voice assistance in Tamil.
+
+## Features
+- Medical report PDF analysis
+- Parameter categorization
+- Tamil voice assistant

analyze.py

@@ -0,0 +1,96 @@
+import os 
+from openai import AzureOpenAI
+import json
+from dotenv import load_dotenv
+
+# ✅ Load the .env file
+load_dotenv()
+
+# Access environment variables (works in both local + Hugging Face Spaces)
+AZURE_API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
+AZURE_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
+MODEL_NAME = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME")
+API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION", "2024-02-15-preview")  # Default if not set
+
+# Initialize AzureOpenAI client
+client = AzureOpenAI(
+    api_key=AZURE_API_KEY,
+    azure_endpoint=AZURE_ENDPOINT,
+    api_version=API_VERSION
+)
+
+def analyze_parameter(test_name, value, reference):
+    """Get AI analysis with strict output control"""
+    prompt = f"""Analyze this medical parameter:
+    Test: {test_name}
+    Value: {value}
+    Reference: {reference}
+
+    Return JSON with:
+    - status: "Good"/"Moderate"/"Immediate Attention"
+    - reason: 20-word explanation
+    - food: 3 specific food items
+    - exercise: 1 measurable activity
+
+    Example: {{
+        "status": "Immediate Attention",
+        "reason": "High LDL increases cardiovascular risk",
+        "food": "Oats, walnuts, olive oil",
+        "exercise": "45-min daily brisk walking"
+    }}"""
+
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.1,
+            response_format={"type": "json_object"}
+        )
+
+        print(json.dumps(response.choices[0].message.content, indent=4))
+        return json.loads(response.choices[0].message.content)
+    except Exception as e:
+        print(f"API Error: {str(e)}")
+        return {
+            "status": "Immediate Attention",
+            "reason": "Requires professional evaluation",
+            "food": "Maintain balanced diet",
+            "exercise": "Consult doctor"
+        }
+
+def generate_report_summary(raw_data):
+    """Generate an overall summary of the medical report"""
+    if not raw_data:
+        return "No medical data found in the report."
+    
+    # Create a simplified list of parameters for the summary
+    parameters = []
+    for item in raw_data:
+        parameters.append(f"{item['test']}: {item['value']} ({item['reference']})")
+    
+    parameters_text = "\n".join(parameters)
+    
+    prompt = f"""Generate a concise summary of this medical report:
+    
+    {parameters_text}
+    
+    Focus on:
+    1. Overall health status
+    2. Key areas of concern (if any)
+    3. General health advice
+    
+    Keep it under 150 words, use simple language, and be honest but reassuring.
+    """
+    
+    try:
+        response = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.3,
+            max_tokens=300
+        )
+        
+        return response.choices[0].message.content
+    except Exception as e:
+        print(f"Summary generation error: {str(e)}")
+        return "Unable to generate summary. Please review the detailed analysis of each parameter."

app.py

@@ -0,0 +1,538 @@
+import streamlit as st
+from pdfhandle import parse_medical_pdf
+from analyze import analyze_parameter, generate_report_summary
+from voice import get_medical_report_answer, play_audio_response
+import os
+import tempfile
+import base64
+import pandas as pd
+
+st.set_page_config(
+    page_title="AI Doctor",
+    layout="wide",
+    page_icon="🩺"
+)
+
+# Custom CSS for enhanced styling
+st.markdown("""
+<style>
+    .main-header {
+        text-align: center; 
+        color: #1e4d8c; 
+        font-size: 3em;
+        margin-bottom: 5px;
+        padding-top: 10px;
+        font-weight: 700;
+        font-family: 'Arial', sans-serif;
+    }
+    
+    .tagline {
+        text-align: center;
+        color: #4a7bb7;
+        font-size: 1.2em;
+        margin-bottom: 30px;
+        font-style: italic;
+        font-weight: 400;
+    }
+    
+    .icon-header {
+        text-align: center;
+        font-size: 2.5em;
+        margin-bottom: 0;
+    }
+    
+    .report-summary {
+        background-color: #f8f9fa;
+        border-left: 5px solid #1e4d8c;
+        padding: 25px;
+        margin-bottom: 20px;
+        border-radius: 8px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+    }
+    
+    .subheader {
+        color: #1e4d8c;
+        border-bottom: 2px solid #eee;
+        padding-bottom: 10px;
+        margin-top: 30px;
+        font-weight: 600;
+    }
+    
+    .good {
+        background-color: #d4edda;
+        border-radius: 8px;
+        padding: 10px;
+        margin-bottom: 10px;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    
+    .moderate {
+        background-color: #fff3cd;
+        border-radius: 8px;
+        padding: 10px;
+        margin-bottom: 10px;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    
+    .attention {
+        background-color: #f8d7da;
+        border-radius: 8px;
+        padding: 10px;
+        margin-bottom: 10px;
+        box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+    }
+    
+    .status-badge {
+        padding: 5px 10px;
+        border-radius: 15px;
+        font-weight: bold;
+        font-size: 0.85em;
+    }
+    
+    .tab-content {
+        padding: 25px 0;
+    }
+    
+    .audio-player {
+        margin-top: 20px;
+        width: 100%;
+        border-radius: 8px;
+    }
+    
+    .dataframe {
+        font-size: 0.9em;
+    }
+    
+    .dataframe th {
+        background-color: #e6f2ff;
+        padding: 10px !important;
+        text-align: left;
+    }
+    
+    .dataframe td {
+        padding: 10px !important;
+    }
+    
+    .stButton > button {
+        background-color: #1e4d8c;
+        color: white;
+        font-weight: 500;
+        border-radius: 8px;
+        padding: 10px 15px;
+        border: none;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.2);
+        transition: all 0.3s ease;
+    }
+    
+    .stButton > button:hover {
+        background-color: #0d3b76;
+        box-shadow: 0 4px 8px rgba(0,0,0,0.3);
+    }
+    
+    .upload-section {
+        background-color: #f0f7ff;
+        padding: 25px;
+        border-radius: 10px;
+        margin-bottom: 25px;
+        text-align: center;
+    }
+    
+    .query-box {
+        background-color: #f0f7ff;
+        border-left: 5px solid #1e4d8c;
+        padding: 15px;
+        margin-bottom: 15px;
+        border-radius: 8px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+    }
+    
+    .response-box {
+        background-color: #f4f9f4;
+        border-left: 5px solid #389738;
+        padding: 15px;
+        margin-bottom: 15px;
+        border-radius: 8px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.1);
+    }
+    
+    .stTextInput > div > div > input {
+        border-radius: 8px;
+        border: 1px solid #bbd0e6;
+        padding: 10px 15px;
+    }
+    
+    .metric-card {
+        background-color: #ffffff;
+        padding: 15px;
+        border-radius: 10px;
+        box-shadow: 0 3px 10px rgba(0,0,0,0.1);
+        text-align: center;
+        transition: transform 0.3s ease;
+    }
+    
+    .metric-card:hover {
+        transform: translateY(-5px);
+    }
+    
+    .metric-good {
+        border-top: 5px solid #28a745;
+    }
+    
+    .metric-moderate {
+        border-top: 5px solid #ffc107;
+    }
+    
+    .metric-attention {
+        border-top: 5px solid #dc3545;
+    }
+    
+    .st-expander {
+        border-radius: 8px;
+        box-shadow: 0 2px 5px rgba(0,0,0,0.05);
+    }
+    
+    footer {
+        text-align: center;
+        padding: 20px 0;
+        color: #6c757d;
+        font-size: 0.9em;
+    }
+    
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 20px;
+    }
+    
+    .stTabs [data-baseweb="tab"] {
+        height: 50px;
+        white-space: pre-wrap;
+        background-color: #f8f9fa;
+        border-radius: 4px 4px 0 0;
+        gap: 1px;
+        padding-top: 10px;
+        padding-bottom: 10px;
+    }
+    
+    .stTabs [aria-selected="true"] {
+        background-color: #1e4d8c;
+        color: white;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Header with icons and tagline
+st.markdown('<div class="icon-header">👨‍⚕️ 🩺</div>', unsafe_allow_html=True)
+st.markdown('<h1 class="main-header">AI Doctor</h1>', unsafe_allow_html=True)
+st.markdown('<p class="tagline">Empowering people through AI-powered health insights in their native language</p>', unsafe_allow_html=True)
+
+# Initialize session state for storing analysis results
+if 'raw_data' not in st.session_state:
+    st.session_state.raw_data = None
+if 'categorized' not in st.session_state:
+    st.session_state.categorized = None
+if 'summary' not in st.session_state:
+    st.session_state.summary = None
+if 'voice_response' not in st.session_state:
+    st.session_state.voice_response = None
+# Add active tab tracking to session state
+if 'active_tab' not in st.session_state:
+    st.session_state.active_tab = 0
+
+# Styled file upload section
+st.markdown('<div class="upload-section">', unsafe_allow_html=True)
+uploaded_file = st.file_uploader(
+    "Upload Medical Report (PDF, max 10MB)", 
+    type="pdf",
+    help="We never store your medical data. All processing happens on-demand.",
+    accept_multiple_files=False
+)
+st.markdown('</div>', unsafe_allow_html=True)
+
+def get_binary_file_downloader_html(bin_file, file_label='File'):
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    b64 = base64.b64encode(data).decode()
+    href = f'<a href="data:audio/mp3;base64,{b64}" download="{file_label}.mp3" class="download-button">Download {file_label} 📥</a>'
+    return href
+
+# Function to update active tab in session state
+def set_active_tab(tab_idx):
+    st.session_state.active_tab = tab_idx
+
+# Main application flow
+if uploaded_file:
+    if uploaded_file.size > 10 * 1024 * 1024:
+        st.error("❌ File size exceeds 10MB limit")
+        st.stop()
+    
+    # Only process the PDF if it hasn't been processed yet or a new file was uploaded
+    file_hash = hash(uploaded_file.getvalue())
+    if 'file_hash' not in st.session_state or file_hash != st.session_state.file_hash:
+        with st.spinner("Analyzing your medical report..."):
+            try:
+                # Process PDF
+                st.session_state.raw_data = parse_medical_pdf(uploaded_file)
+                st.session_state.file_hash = file_hash
+                
+                if not st.session_state.raw_data:
+                    st.error("No parameters found in document. Please ensure this is a standard medical report.")
+                    st.stop()
+                
+                # Generate summary
+                st.session_state.summary = generate_report_summary(st.session_state.raw_data)
+                
+                # Process analysis
+                categorized = {
+                    "Good": [],
+                    "Moderate": [],
+                    "Immediate Attention": []
+                }
+                
+                for item in st.session_state.raw_data:
+                    analysis = analyze_parameter(
+                        item["test"], 
+                        item["value"], 
+                        item["reference"]
+                    )
+                    row = {
+                        "Parameter": item["test"],
+                        "Value": f"{item['value']} (Ref: {item['reference']})",
+                        "Clinical Significance": analysis["reason"],
+                        "Dietary Recommendation": analysis["food"],
+                        "Activity Guidance": analysis["exercise"],
+                        "Status": analysis["status"]
+                    }
+                    categorized[analysis["status"]].append(row)
+                
+                st.session_state.categorized = categorized
+                
+            except Exception as e:
+                st.error(f"Analysis failed: {str(e)}")
+                st.stop()
+    
+    # Create tabs with specified active tab from session state and improved icons
+    tab_titles = ["📊 Summary", "🔍 Detailed Analysis", "🗣️ Voice Assistant"]
+    
+    # Create tab containers with the active tab selected
+    active_tab_index = st.session_state.active_tab
+    tabs = st.tabs(tab_titles)
+    
+    # Tab 1: Summary with enhanced cards
+    with tabs[0]:
+        st.markdown("<h2 class='subheader'>Report Summary</h2>", unsafe_allow_html=True)
+        st.markdown(f"<div class='report-summary'>{st.session_state.summary}</div>", unsafe_allow_html=True)
+        
+        # Summary stats with improved metric cards
+        st.markdown("<h3>Health Parameters Overview</h3>", unsafe_allow_html=True)
+        col1, col2, col3 = st.columns(3)
+        
+        with col1:
+            good_count = len(st.session_state.categorized["Good"])
+            st.markdown(f"""
+            <div class="metric-card metric-good">
+                <h4>Good Parameters</h4>
+                <h2>{good_count}</h2>
+                <p>Normal range values</p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+        with col2:
+            moderate_count = len(st.session_state.categorized["Moderate"])
+            st.markdown(f"""
+            <div class="metric-card metric-moderate">
+                <h4>Moderate Parameters</h4>
+                <h2>{moderate_count}</h2>
+                <p>Borderline values</p>
+            </div>
+            """, unsafe_allow_html=True)
+            
+        with col3:
+            attention_count = len(st.session_state.categorized["Immediate Attention"])
+            st.markdown(f"""
+            <div class="metric-card metric-attention">
+                <h4>Needs Attention</h4>
+                <h2>{attention_count}</h2>
+                <p>Critical values</p>
+            </div>
+            """, unsafe_allow_html=True)
+    
+    # Tab 2: Detailed Analysis with improved styling
+    with tabs[1]:
+        st.markdown("<h2 class='subheader'>Detailed Analysis</h2>", unsafe_allow_html=True)
+        st.warning("❗ This tool provides general insights only. Always consult a healthcare professional.")
+        
+        # Create tables for each status category with improved styling
+        for status in ["Immediate Attention", "Moderate", "Good"]:
+            if data := st.session_state.categorized[status]:
+                status_color = "attention" if status == "Immediate Attention" else "moderate" if status == "Moderate" else "good"
+                status_icon = "⚠️" if status == "Immediate Attention" else "⚠️" if status == "Moderate" else "✅"
+                
+                with st.expander(f"{status_icon} {status} Parameters ({len(data)})", expanded=(status == "Immediate Attention")):
+                    # Convert list of dictionaries to DataFrame for tabular display
+                    df = pd.DataFrame(data)
+                    
+                    # Apply styling based on status
+                    st.markdown(f"<div class='{status_color}'>", unsafe_allow_html=True)
+                    st.dataframe(
+                        df,
+                        hide_index=True,
+                        use_container_width=True
+                    )
+                    st.markdown("</div>", unsafe_allow_html=True)
+
+    # Tab 3: Voice Assistant with improved layout
+    with tabs[2]:
+        st.markdown("<h2 class='subheader'>Voice Assistant (Tamil)</h2>", unsafe_allow_html=True)
+        st.info("You can ask questions about your medical report in Tamil. The assistant will respond in Tamil.")
+    
+        # Create a placeholder for status messages
+        status_placeholder = st.empty()
+        
+        # Remove doctor icon and adjust spacing
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Button for voice input
+            if st.button("🎤 Ask Questions (you may speak in Tamil)", type="primary", key="listen_button"):
+                # Update the active tab in session state
+                st.session_state.active_tab = 2
+                
+                # Process voice input
+                st.session_state.voice_response = get_medical_report_answer(st.session_state.summary)
+                
+                # Use JavaScript to ensure we stay on Voice Assistant tab
+                st.components.v1.html("""
+                <script>
+                    // Wait a moment for the UI to update
+                    setTimeout(function() {
+                        // Select the Voice Assistant tab (index 2)
+                        window.parent.document.querySelectorAll('[data-baseweb="tab"]')[2].click();
+                    }, 100);
+                </script>
+                """, height=0)
+        
+        with col2:
+            # Text input as an alternative with better styling
+            tamil_text = st.text_input("💬 Or type your question in Tamil:", placeholder="என் இரத்த அழுத்தம் எப்படி உள்ளது?")
+            if tamil_text and st.button("✓ Submit", key="submit_button"):
+                # Update the active tab in session state
+                st.session_state.active_tab = 2
+                
+                with st.spinner("Processing your query..."):
+                    st.session_state.voice_response = get_medical_report_answer(st.session_state.summary, tamil_text)
+                
+                # Use JavaScript to ensure we stay on Voice Assistant tab
+                st.components.v1.html("""
+                <script>
+                    // Wait a moment for the UI to update
+                    setTimeout(function() {
+                        // Select the Voice Assistant tab (index 2)
+                        window.parent.document.querySelectorAll('[data-baseweb="tab"]')[2].click();
+                    }, 100);
+                </script>
+                """, height=0)
+        
+        # Display voice response in a more visually appealing way
+        if 'voice_response' in st.session_state and st.session_state.voice_response:
+            response = st.session_state.voice_response
+            
+            # Clear any status messages
+            status_placeholder.empty()
+            
+            # Original query display with improved styling
+            if response["original_query"]:
+                st.markdown("<h3>Your Question</h3>", unsafe_allow_html=True)
+                
+                st.markdown(f"""
+                <div class="query-box">
+                    <strong>Tamil:</strong> {response['original_query']}<br>
+                    <strong>English:</strong> {response['translated_query']}
+                </div>
+                """, unsafe_allow_html=True)
+            
+            # Response display with improved styling
+            st.markdown("<h3>Response</h3>", unsafe_allow_html=True)
+            
+            with st.expander("🇺🇸 English Response", expanded=False):
+                st.markdown(f"<div class='response-box'>{response['english_response']}</div>", unsafe_allow_html=True)
+                
+            with st.expander("🇮🇳 Tamil Response", expanded=True):
+                st.markdown(f"<div class='response-box'>{response['tamil_response']}</div>", unsafe_allow_html=True)
+            
+            # Audio playback with auto-play and improved styling
+            if response["audio_file"] and os.path.exists(response["audio_file"]):
+                st.markdown("<h3>🔊 Voice Response</h3>", unsafe_allow_html=True)
+                
+                # Auto-play the audio
+                play_audio_response(response["audio_file"])
+                
+                # Display audio controls for manual replay
+                st.audio(response["audio_file"])
+                
+                # Download button with better styling
+                st.markdown(get_binary_file_downloader_html(response["audio_file"], 'Audio Response'), unsafe_allow_html=True)
+    
+    # We don't need complex JavaScript for tabs anymore since we're using direct click events
+    # This is much simpler and more reliable
+
+else:
+    # Show info when no file is uploaded with more attractive layout
+    st.info("Upload your medical report PDF to get started with your personalized health analysis")
+    
+    # Sample information about the app with better formatting
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.markdown("""
+        <div style="background-color: #f0f7ff; padding: 20px; border-radius: 10px; height: 100%;">
+        <h3>How it works</h3>
+        
+        <ol style="margin-top: 15px;">
+            <li><strong>Upload your medical report</strong> in PDF format</li>
+            <li>Our AI analyzes each parameter and provides:
+                <ul>
+                    <li>Status classification</li>
+                    <li>Clinical significance</li> 
+                    <li>Dietary recommendations</li>
+                    <li>Activity guidance</li>
+                </ul>
+            </li>
+            <li><strong>Ask questions in Tamil</strong> about your report using voice or text</li>
+        </ol>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown("""
+        <div style="background-color: #f0f7ff; padding: 20px; border-radius: 10px; height: 100%;">
+        <h3>Privacy & Security</h3>
+        
+        <ul style="margin-top: 15px;">
+            <li>Your medical data is processed securely and never stored</li>
+            <li>All analysis happens on-demand</li>
+            <li>Voice data is only used for processing your queries</li>
+            <li>We prioritize your data privacy and security</li>
+        </ul>
+        </div>
+        """, unsafe_allow_html=True)
+
+# Footer with improved styling
+st.markdown("""
+<footer>
+    <hr style="margin: 20px 0;">
+    <div>
+        <p>AI Doctor © 2025 | Empowering people through AI-powered health insights</p>
+        <p style="font-size: 0.8em; color: #999;">For educational purposes only. Always consult a healthcare professional for medical advice.</p>
+    </div>
+</footer>
+""", unsafe_allow_html=True)
+
+# Display LinkedIn profile
+st.markdown(
+    """
+    <div style="text-align: center; font-size: 15px;">
+        <a href="https://www.linkedin.com/in/tamilprabaharan/" target="_blank">Visit my LinkedIn Profile</a>
+    </div>
+    """, 
+    unsafe_allow_html=True
+)

pdfhandle.py

@@ -0,0 +1,157 @@
+# pdfhandle.py (Enhanced with AI fallback)
+import pdfplumber
+import re
+import logging
+import os
+from langchain_community.chat_models import AzureChatOpenAI
+#from langchain.chat_models import AzureChatOpenAI
+from langchain.schema import HumanMessage
+from langchain.output_parsers import PydanticOutputParser
+from pydantic import BaseModel, Field
+from typing import List
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class MedicalParameter(BaseModel):
+    test: str = Field(description="Name of the medical test")
+    value: str = Field(description="Observed value of the test")
+    reference: str = Field(description="Reference range with units if available")
+
+class MedicalReport(BaseModel):
+    parameters: List[MedicalParameter] = Field(description="List of medical parameters from the report")
+
+def parse_medical_pdf(pdf_file):
+    """Enhanced PDF parser with AI fallback for medical reports"""
+    # First attempt with regex-based parsing
+    results = standard_parse(pdf_file)
+    
+    # If standard parsing yields no results, try AI-based parsing
+    if not results:
+        logger.info("Standard parsing yielded no results. Trying AI-based parsing...")
+        results = ai_based_parse(pdf_file)
+    
+    return results
+
+def standard_parse(pdf_file):
+    """Standard regex-based parsing method"""
+    results = []
+    header_found = False
+    header_pattern = re.compile(
+        r'TEST\s+NAME\s+OBSERVED\s+VALUE\s+UNITS\s+BIO\.?\s+REF\.?\s*INTERVAL',
+        re.IGNORECASE
+    )
+    
+    # Extended pattern to handle common variations in medical reports
+    data_pattern = re.compile(
+        r'^(?P<test>.+?)\s+'          # Test name (non-greedy match)
+        r'(?P<value>\d+\.?\d*)\s+'    # Numeric value
+        r'(?P<units>[^\s]+)\s+'       # Units (no spaces)
+        r'(?P<ref>.+)$'               # Reference range
+    )
+
+    with pdfplumber.open(pdf_file) as pdf:
+        for page in pdf.pages:
+            text = page.extract_text()
+            lines = [line.strip() for line in text.split('\n') if line.strip()]
+            
+            for line in lines:
+                # Skip disclaimers and empty lines
+                if not line or line.startswith('Disclaimer'):
+                    continue
+                
+                # Detect header row
+                if header_pattern.search(line):
+                    header_found = True
+                    logger.info(f"Header found: {line}")
+                    continue
+                
+                if header_found:
+                    # Skip section headers (all caps without numbers)
+                    if re.match(r'^[A-Z\s/]+$', line) and not re.search(r'\d', line):
+                        logger.debug(f"Skipping section: {line}")
+                        continue
+                    
+                    # Extract data using regex
+                    if match := data_pattern.match(line):
+                        data = match.groupdict()
+                        results.append({
+                            "test": data['test'].strip(),
+                            "value": data['value'],
+                            "reference": f"{data['ref']} {data['units']}".strip()
+                        })
+                        logger.info(f"Valid row: {data}")
+                    else:
+                        logger.debug(f"Skipped line: {line}")
+    
+    return results
+
+def ai_based_parse(pdf_file):
+    """AI-based parsing using LangChain and Azure OpenAI"""
+    try:
+        # Configure Azure OpenAI client
+        llm = AzureChatOpenAI(
+            openai_api_version=os.getenv("AZURE_OPENAI_API_VERSION", "2024-02-15-preview"),
+            azure_deployment=os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME"),
+            openai_api_key=os.getenv("AZURE_OPENAI_API_KEY"),
+            azure_endpoint=os.getenv("AZURE_OPENAI_ENDPOINT")
+        )
+        
+        # Extract text from PDF
+        full_text = ""
+        with pdfplumber.open(pdf_file) as pdf:
+            for page in pdf.pages:
+                full_text += page.extract_text() + "\n"
+        
+        # Define the output parser
+        parser = PydanticOutputParser(pydantic_object=MedicalReport)
+        
+        # Create the prompt
+        prompt = f"""
+        You are a medical data extraction expert. Extract all medical test parameters from this report.
+        
+        Medical Report Text:
+        {full_text}
+        
+        Extract each test with its observed value and reference range. Format your response exactly as in this example:
+        {{
+            "parameters": [
+                {{
+                    "test": "Hemoglobin",
+                    "value": "14.5",
+                    "reference": "13.0 - 17.0 g/dL"
+                }},
+                {{
+                    "test": "Total Cholesterol",
+                    "value": "198",
+                    "reference": "<200 mg/dL"
+                }}
+            ]
+        }}
+        
+        Extract only actual test parameters. Include units in the reference field.
+        {parser.get_format_instructions()}
+        """
+        
+        # Get response from the LLM
+        messages = [HumanMessage(content=prompt)]
+        response = llm.predict_messages(messages)
+        
+        # Parse the response
+        report = parser.parse(response.content)
+        
+        # Convert to the expected format
+        results = []
+        for param in report.parameters:
+            results.append({
+                "test": param.test,
+                "value": param.value,
+                "reference": param.reference
+            })
+        
+        logger.info(f"AI parsing successful. Extracted {len(results)} parameters.")
+        return results
+        
+    except Exception as e:
+        logger.error(f"AI-based parsing failed: {str(e)}")
+        return []

requirements.txt

@@ -0,0 +1,14 @@
+streamlit>=1.22
+pdfplumber>=0.9
+openai>=1.0.0
+python-dotenv>=1.0
+pyyaml>=6.0
+langchain-community>=0.0.13
+langchain>=0.1.0
+pydantic>=2.5.0
+typing-extensions>=4.8.0
+SpeechRecognition>=3.10.0
+google-generativeai>=0.3.0
+pygame>=2.5.0
+translate>=3.6.1
+google-cloud-texttospeech>=2.14.1

voice.py

@@ -0,0 +1,374 @@
+# voice.py (Updated with Azure OpenAI integration)
+import os
+import speech_recognition as sr
+import google.generativeai as genai
+import tempfile
+import logging
+from io import BytesIO
+import re
+import pygame
+from translate import Translator
+import base64
+import streamlit as st
+from google.cloud import texttospeech
+import json
+from openai import AzureOpenAI
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Get API keys from environment variables
+gemini_api_key = os.getenv('GEMINI_API_KEY', "AIzaSyCZL29aqWTmP_NTzkGILK4Kujx_MuyRAs4")
+google_tts_credentials = os.getenv('GOOGLE_TTS_CREDENTIALS', "D:/AI and Data Science/Projects/AI DoctorV2/tamiltextspeech-458116-147b3efcaf84.json")
+
+# Azure OpenAI configuration
+AZURE_API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
+AZURE_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
+MODEL_NAME = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME")
+API_VERSION = os.getenv("AZURE_OPENAI_API_VERSION", "2024-02-15-preview")
+
+# Initialize Azure OpenAI client
+try:
+    azure_client = AzureOpenAI(
+        api_key=AZURE_API_KEY,
+        azure_endpoint=AZURE_ENDPOINT,
+        api_version=API_VERSION
+    )
+    logger.info("Azure OpenAI client initialized successfully")
+except Exception as e:
+    logger.error(f"Failed to initialize Azure OpenAI client: {str(e)}")
+    azure_client = None
+
+# Initialize Google TTS client
+try:
+    # Set credentials from JSON file
+    if os.path.exists(google_tts_credentials):
+        os.environ["GOOGLE_APPLICATION_CREDENTIALS"] = google_tts_credentials
+        tts_client = texttospeech.TextToSpeechClient()
+        logger.info("Google Text-to-Speech client initialized successfully")
+    else:
+        logger.warning(f"Google TTS credentials file not found: {google_tts_credentials}")
+        tts_client = None
+except Exception as e:
+    logger.error(f"Failed to initialize Google TTS: {str(e)}")
+    tts_client = None
+
+# Configure Gemini for translations only
+genai.configure(api_key=gemini_api_key)
+model = genai.GenerativeModel('gemini-1.5-pro')
+
+def listen_tamil():
+    """Listen to Tamil speech with improved end detection and error handling"""
+    recognizer = sr.Recognizer()
+    with sr.Microphone() as source:
+        logger.info("Listening for Tamil speech...")
+        # Adjust for ambient noise
+        recognizer.adjust_for_ambient_noise(source, duration=1.5)  # Increased duration
+        
+        # Improve speech detection with better pause threshold
+        recognizer.pause_threshold = 1.0  # Increased pause threshold for better recognition
+        recognizer.energy_threshold = 300  # Adjust sensitivity
+        
+        try:
+            st.info("🎤 Listening... Please speak in Tamil")
+            audio = recognizer.listen(source, timeout=15, phrase_time_limit=30)  # Extended timeout
+            logger.info("Speech detected, processing...")
+            st.success("✅ Speech recorded! Processing...")
+        except sr.WaitTimeoutError:
+            logger.error("No speech detected")
+            st.error("❌ No speech detected. Please try again.")
+            return None
+    
+    try:
+        # Using Google's speech recognition with Tamil language
+        tamil_text = recognizer.recognize_google(audio, language='ta-IN')
+        logger.info(f"Recognized Tamil text: {tamil_text}")
+        return tamil_text
+    except sr.UnknownValueError:
+        logger.error("Could not understand audio")
+        st.error("❌ Could not understand the speech. Please try again more clearly.")
+        return None
+    except sr.RequestError as e:
+        logger.error(f"Speech recognition service error: {e}")
+        st.error("❌ Speech recognition service error. Please try again later.")
+        return None
+
+def translate_tamil_to_english(tamil_text):
+    """Translate Tamil text to English while preserving numbers"""
+    if not tamil_text:
+        return ""
+        
+    # Extract numbers from the text
+    numbers = re.findall(r'\d+\.?\d*', tamil_text)
+    
+    # Replace numbers with placeholders
+    for i, num in enumerate(numbers):
+        tamil_text = tamil_text.replace(num, f'NUM{i}PLACEHOLDER')
+    
+    try:
+        # Use Gemini for more accurate translation
+        prompt = f"""Translate this Tamil text to English accurately, preserving the exact meaning:
+        
+        {tamil_text}
+        
+        Return only the translation, nothing else."""
+        
+        response = model.generate_content(prompt)
+        translation = response.text
+        
+        # Fallback to basic translator if Gemini fails
+        if not translation or len(translation) < 5:
+            translator = Translator(to_lang="en", from_lang="ta")
+            translation = translator.translate(tamil_text)
+    
+        # Restore numbers
+        for i, num in enumerate(numbers):
+            translation = translation.replace(f'NUM{i}PLACEHOLDER', num)
+            
+        # Clean up any artifacts
+        translation = re.sub(r'\s+', ' ', translation).strip()
+        logger.info(f"Translation result: {translation}")
+        
+        return translation
+        
+    except Exception as e:
+        logger.error(f"Translation error: {e}")
+        # Try fallback translator
+        try:
+            translator = Translator(to_lang="en", from_lang="ta")
+            return translator.translate(tamil_text)
+        except:
+            return tamil_text  # Return original if translation fails
+
+def translate_english_to_tamil(english_text):
+    """Translate English text to Tamil while preserving numbers"""
+    if not english_text:
+        return ""
+        
+    # Extract numbers from the text
+    numbers = re.findall(r'\d+\.?\d*', english_text)
+    
+    # Replace numbers with placeholders
+    for i, num in enumerate(numbers):
+        english_text = english_text.replace(num, f'NUM{i}PLACEHOLDER')
+    
+    try:
+        # Use Gemini for more accurate translation
+        prompt = f"""Translate this English text to Tamil accurately, preserving the exact meaning:
+        
+        {english_text}
+        
+        Return only the translation, nothing else."""
+        
+        response = model.generate_content(prompt)
+        translation = response.text
+        
+        # Fallback to basic translator if Gemini fails
+        if not translation or len(translation) < 5:
+            translator = Translator(to_lang="ta", from_lang="en")
+            translation = translator.translate(english_text)
+    
+        # Restore numbers
+        for i, num in enumerate(numbers):
+            translation = translation.replace(f'NUM{i}PLACEHOLDER', num)
+            
+        # Clean up any artifacts
+        translation = re.sub(r'\s+', ' ', translation).strip()
+        logger.info(f"Translation to Tamil: {translation}")
+        
+        return translation
+        
+    except Exception as e:
+        logger.error(f"Translation error: {e}")
+        # Try fallback translator
+        try:
+            translator = Translator(to_lang="ta", from_lang="en")
+            return translator.translate(english_text)
+        except:
+            return english_text  # Return original if translation fails
+
+def process_with_azure_openai(english_text, medical_summary):
+    """Process medical report with Azure OpenAI using empathetic approach"""
+    if not english_text or not medical_summary:
+        return "No data available to process."
+    
+    if not azure_client:
+        logger.error("Azure OpenAI client not initialized")
+        return "Sorry, the AI service is currently unavailable."
+    
+    try:
+        prompt = f"""You are a compassionate medical assistant. Analyze the medical report and respond to the user's question.
+
+        User's question: {english_text}
+        
+        Requirements:
+        1. Respond only if the question relates to the medical report
+        2. Keep the response under 100 words
+        3. Use simple, non-medical language when possible
+        4. Focus on answering the specific question
+        5. Be empathetic and reassuring (avoid causing panic)
+        6. Include positive, actionable health improvement suggestions
+        7. Use phrases like "Don't worry", "You can improve this by", "This is manageable"
+        
+        Medical Report:
+        {medical_summary}
+        """
+        
+        response = azure_client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.3,
+            max_tokens=400
+        )
+        
+        processed_text = response.choices[0].message.content
+        logger.info("Successfully processed query with Azure OpenAI")
+        return processed_text
+        
+    except Exception as e:
+        logger.error(f"Error processing with Azure OpenAI: {str(e)}")
+        return "I apologize, but I couldn't process your question about the medical report."
+
+def text_to_speech(text, output_file="output.mp3"):
+    """Convert text to speech using Google TTS"""
+    if not text:
+        logger.warning("No text provided for speech synthesis")
+        return None
+        
+    try:
+        if tts_client:
+            # Configure the synthesis input
+            synthesis_input = texttospeech.SynthesisInput(text=text)
+            
+            # Build the voice request, selecting Tamil language and female voice
+            voice = texttospeech.VoiceSelectionParams(
+                language_code="ta-IN",
+                ssml_gender=texttospeech.SsmlVoiceGender.FEMALE
+            )
+            
+            # Select the audio file type with improved settings
+            audio_config = texttospeech.AudioConfig(
+                audio_encoding=texttospeech.AudioEncoding.MP3,
+                speaking_rate=0.9,  # Slightly slower for better comprehension
+                pitch=0.0,  # Normal pitch
+                volume_gain_db=1.0  # Slightly louder
+            )
+            
+            # Perform the text-to-speech request
+            response = tts_client.synthesize_speech(
+                input=synthesis_input,
+                voice=voice,
+                audio_config=audio_config
+            )
+            
+            # Save the response to a file
+            with open(output_file, "wb") as out:
+                out.write(response.audio_content)
+                logger.info(f"Audio content written to file {output_file}")
+            
+            # Return audio bytes for streaming
+            audio_bytes = BytesIO(response.audio_content)
+            return audio_bytes
+        else:
+            logger.warning("Google TTS client not available")
+            return None
+            
+    except Exception as e:
+        logger.error(f"Error in text-to-speech: {e}")
+        return None
+
+def play_audio(audio_file):
+    """Play audio file using pygame"""
+    try:
+        pygame.mixer.init()
+        pygame.mixer.music.load(audio_file)
+        pygame.mixer.music.play()
+        while pygame.mixer.music.get_busy():
+            pygame.time.Clock().tick(10)
+    except Exception as e:
+        logger.error(f"Error playing audio: {e}")
+
+def get_base64_audio(audio_file):
+    """Convert audio file to base64 for embedding"""
+    with open(audio_file, "rb") as f:
+        data = f.read()
+    return base64.b64encode(data).decode()
+
+def play_audio_response(audio_file):
+    """Play audio file automatically in browser"""
+    if audio_file and os.path.exists(audio_file):
+        try:
+            # Create HTML with autoplay audio element
+            audio_html = f"""
+            <audio id="response_audio" autoplay="true">
+                <source src="data:audio/mp3;base64,{get_base64_audio(audio_file)}" type="audio/mp3">
+            </audio>
+            <script>
+                // Ensure audio plays automatically
+                var audio = document.getElementById("response_audio");
+                audio.play().catch(function(error) {{
+                    console.error("Audio playback failed:", error);
+                }});
+            </script>
+            """
+            st.components.v1.html(audio_html, height=0)
+            logger.info("Audio playback triggered")
+        except Exception as e:
+            logger.error(f"Error in auto-play: {e}")
+
+def get_medical_report_answer(medical_summary, tamil_text=None):
+    """Process a voice query about the medical report"""
+    # If tamil_text is not provided, listen for it
+    if not tamil_text:
+        tamil_text = listen_tamil()
+        
+    if not tamil_text:
+        return {
+            "original_query": None,
+            "translated_query": None,
+            "english_response": "No speech detected. Please try again.",
+            "tamil_response": "பேச்சு இல்லை. மீண்டும் முயற்சிக்கவும்.",
+            "audio_file": None
+        }
+    
+    # Step 2: Translate Tamil to English
+    english_query = translate_tamil_to_english(tamil_text)
+    
+    # Step 3: Process with Azure OpenAI instead of Gemini
+    english_response = process_with_azure_openai(english_query, medical_summary)
+    
+    # Step 4: Translate response back to Tamil
+    tamil_response = translate_english_to_tamil(english_response)
+    
+    # Add empathetic phrases in Tamil if they're not already present
+    empathetic_phrases = [
+        "கவலைப்பட வேண்டாம்",  # Don't worry
+        "இது கையாளக்கூடியது",   # This is manageable
+        "இதை மேம்படுத்த முடியும்"  # You can improve this
+    ]
+    
+    # Check if at least one empathetic phrase is present
+    has_empathetic_phrase = any(phrase in tamil_response for phrase in empathetic_phrases)
+    
+    # Add an empathetic phrase at the beginning if none found
+    if not has_empathetic_phrase:
+        tamil_response = f"{empathetic_phrases[0]}. {tamil_response}"
+    
+    # Step 5: Convert to speech
+    audio_file = "response_audio.mp3"
+    audio_data = text_to_speech(tamil_response, audio_file)
+    
+    # Log success or failure of audio generation
+    if audio_data:
+        logger.info("Audio response generated successfully")
+    else:
+        logger.warning("Failed to generate audio response")
+        
+    return {
+        "original_query": tamil_text,
+        "translated_query": english_query,
+        "english_response": english_response,
+        "tamil_response": tamil_response,
+        "audio_file": audio_file if audio_data else None
+    }