Upload 12 files

.gitignore

@@ -0,0 +1,12 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+venv/
+env/
+.env
+.venv
+chroma_db/
+*.pdf
+.DS_Store

app.py

@@ -0,0 +1,234 @@
+"""
+Lab Report Decoder - Flask Application
+Professional web interface for lab report analysis
+"""
+
+from flask import Flask, render_template, request, jsonify, session
+from werkzeug.utils import secure_filename
+import os
+import tempfile
+import secrets
+from pdf_extractor import LabReportExtractor
+from rag_engine import LabReportRAG
+from dotenv import load_dotenv
+
+load_dotenv()
+
+app = Flask(__name__)
+app.secret_key = os.getenv('SECRET_KEY', secrets.token_hex(16))
+
+# Note: No OpenAI API key needed - using Hugging Face models!
+app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB max file size
+app.config['UPLOAD_FOLDER'] = tempfile.gettempdir()
+
+# Initialize RAG system (singleton)
+rag_system = None
+
+def get_rag_system():
+    """Lazy load RAG system"""
+    global rag_system
+    if rag_system is None:
+        rag_system = LabReportRAG()
+    return rag_system
+
+@app.route('/')
+def index():
+    """Main page"""
+    return render_template('index.html')
+
+@app.route('/api/upload', methods=['POST'])
+def upload_file():
+    """Handle PDF upload and extraction"""
+    try:
+        if 'file' not in request.files:
+            return jsonify({'error': 'No file provided'}), 400
+        
+        file = request.files['file']
+        
+        if file.filename == '':
+            return jsonify({'error': 'No file selected'}), 400
+        
+        if not file.filename.lower().endswith('.pdf'):
+            return jsonify({'error': 'Only PDF files are allowed'}), 400
+        
+        # Save file temporarily
+        filename = secure_filename(file.filename)
+        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
+        file.save(filepath)
+        
+        try:
+            # Extract lab results
+            extractor = LabReportExtractor()
+            results = extractor.extract_from_pdf(filepath)
+            
+            if not results:
+                return jsonify({'error': 'No lab results found in PDF'}), 400
+            
+            # Convert to JSON-serializable format
+            results_data = [
+                {
+                    'test_name': r.test_name,
+                    'value': r.value,
+                    'unit': r.unit,
+                    'reference_range': r.reference_range,
+                    'status': r.status
+                }
+                for r in results
+            ]
+            
+            # Store in session
+            session['results'] = results_data
+            
+            return jsonify({
+                'success': True,
+                'results': results_data,
+                'count': len(results_data)
+            })
+        
+        finally:
+            # Clean up temp file
+            if os.path.exists(filepath):
+                os.remove(filepath)
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/explain', methods=['POST'])
+def explain_results():
+    """Generate explanations for lab results"""
+    try:
+        results_data = session.get('results')
+        
+        if not results_data:
+            return jsonify({'error': 'No results found. Please upload a PDF first.'}), 400
+        
+        # Convert back to LabResult objects
+        from pdf_extractor import LabResult
+        results = [
+            LabResult(
+                test_name=r['test_name'],
+                value=r['value'],
+                unit=r['unit'],
+                reference_range=r['reference_range'],
+                status=r['status']
+            )
+            for r in results_data
+        ]
+        
+        # Generate explanations
+        rag = get_rag_system()
+        explanations = rag.explain_all_results(results)
+        
+        return jsonify({
+            'success': True,
+            'explanations': explanations
+        })
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/ask', methods=['POST'])
+def ask_question():
+    """Answer follow-up questions"""
+    try:
+        data = request.get_json()
+        question = data.get('question', '').strip()
+        
+        if not question:
+            return jsonify({'error': 'No question provided'}), 400
+        
+        results_data = session.get('results')
+        
+        if not results_data:
+            return jsonify({'error': 'No results found. Please upload a PDF first.'}), 400
+        
+        # Convert back to LabResult objects
+        from pdf_extractor import LabResult
+        results = [
+            LabResult(
+                test_name=r['test_name'],
+                value=r['value'],
+                unit=r['unit'],
+                reference_range=r['reference_range'],
+                status=r['status']
+            )
+            for r in results_data
+        ]
+        
+        # Get answer
+        rag = get_rag_system()
+        answer = rag.answer_followup_question(question, results)
+        
+        return jsonify({
+            'success': True,
+            'question': question,
+            'answer': answer
+        })
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/summary', methods=['GET'])
+def get_summary():
+    """Generate overall summary"""
+    try:
+        results_data = session.get('results')
+        
+        if not results_data:
+            return jsonify({'error': 'No results found. Please upload a PDF first.'}), 400
+        
+        # Convert back to LabResult objects
+        from pdf_extractor import LabResult
+        results = [
+            LabResult(
+                test_name=r['test_name'],
+                value=r['value'],
+                unit=r['unit'],
+                reference_range=r['reference_range'],
+                status=r['status']
+            )
+            for r in results_data
+        ]
+        
+        # Generate summary
+        rag = get_rag_system()
+        summary = rag.generate_summary(results)
+        
+        # Calculate statistics
+        stats = {
+            'total': len(results),
+            'normal': sum(1 for r in results if r.status == 'normal'),
+            'high': sum(1 for r in results if r.status == 'high'),
+            'low': sum(1 for r in results if r.status == 'low'),
+            'unknown': sum(1 for r in results if r.status == 'unknown')
+        }
+        
+        return jsonify({
+            'success': True,
+            'summary': summary,
+            'stats': stats
+        })
+    
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/api/clear', methods=['POST'])
+def clear_session():
+    """Clear session data"""
+    session.clear()
+    return jsonify({'success': True})
+
+@app.errorhandler(413)
+def request_entity_too_large(error):
+    return jsonify({'error': 'File too large. Maximum size is 16MB.'}), 413
+
+@app.errorhandler(500)
+def internal_error(error):
+    return jsonify({'error': 'Internal server error'}), 500
+
+if __name__ == '__main__':
+    if not(os.path.isdir('chroma_db/')):
+         os.system("python build_vector_db.py")
+    #any available port
+    port = int(os.environ.get("PORT", 5000))
+    app.run(host="0.0.0.0", port=port)

build_vector_db.py

@@ -0,0 +1,212 @@
+"""
+Build Vector Database for Lab Report Decoder
+Uses Hugging Face sentence-transformers for embeddings
+"""
+
+import os
+from pathlib import Path
+from sentence_transformers import SentenceTransformer
+import chromadb
+from chromadb.config import Settings
+import glob
+
+def load_documents_from_directory(directory: str) -> list:
+    """Load all text files from a directory"""
+    documents = []
+    
+    if not os.path.exists(directory):
+        print(f"⚠️  Directory not found: {directory}")
+        return documents
+    
+    # Find all .txt files
+    txt_files = glob.glob(os.path.join(directory, "**", "*.txt"), recursive=True)
+    
+    for filepath in txt_files:
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                content = f.read()
+                if content.strip():
+                    documents.append({
+                        'content': content,
+                        'source': filepath,
+                        'filename': os.path.basename(filepath)
+                    })
+        except Exception as e:
+            print(f"Error reading {filepath}: {e}")
+    
+    return documents
+
+def chunk_text(text: str, chunk_size: int = 1000, overlap: int = 200) -> list:
+    """Split text into overlapping chunks"""
+    chunks = []
+    start = 0
+    
+    while start < len(text):
+        end = start + chunk_size
+        chunk = text[start:end]
+        
+        # Try to break at sentence boundary
+        if end < len(text):
+            last_period = chunk.rfind('.')
+            last_newline = chunk.rfind('\n')
+            break_point = max(last_period, last_newline)
+            
+            if break_point > chunk_size * 0.5:  # Only if break point is reasonable
+                chunk = chunk[:break_point + 1]
+                end = start + break_point + 1
+        
+        chunks.append(chunk.strip())
+        start = end - overlap
+    
+    return chunks
+
+def build_knowledge_base():
+    """Build the vector database from medical documents"""
+    
+    print("📚 Loading medical documents...")
+    
+    # Load documents from data directory
+    data_dir = 'data/'
+    all_documents = []
+    
+    if not os.path.exists(data_dir):
+        print(f"⚠️  Creating data directory: {data_dir}")
+        os.makedirs(data_dir, exist_ok=True)
+        os.makedirs(os.path.join(data_dir, 'lab_markers'), exist_ok=True)
+        os.makedirs(os.path.join(data_dir, 'nutrition'), exist_ok=True)
+        os.makedirs(os.path.join(data_dir, 'conditions'), exist_ok=True)
+        print("⚠️  Please add medical reference documents to the data/ folder")
+        return None
+    
+    # Load from all subdirectories
+    for subdir in ['lab_markers', 'nutrition', 'conditions']:
+        subdir_path = os.path.join(data_dir, subdir)
+        docs = load_documents_from_directory(subdir_path)
+        all_documents.extend(docs)
+    
+    if not all_documents:
+        print("⚠️  No documents found in data/ directory")
+        print("Please add .txt files with medical information")
+        return None
+    
+    print(f"✅ Loaded {len(all_documents)} documents")
+    
+    # Chunk documents
+    print("✂️  Splitting documents into chunks...")
+    all_chunks = []
+    all_metadata = []
+    
+    for doc in all_documents:
+        chunks = chunk_text(doc['content'], chunk_size=1000, overlap=200)
+        for i, chunk in enumerate(chunks):
+            all_chunks.append(chunk)
+            all_metadata.append({
+                'source': doc['source'],
+                'filename': doc['filename'],
+                'chunk_id': i
+            })
+    
+    print(f"✅ Created {len(all_chunks)} text chunks")
+    
+    # Load embedding model
+    print("🧠 Loading embedding model (this may take a moment)...")
+    embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+    print("✅ Embedding model loaded")
+    
+    # Create embeddings
+    print("🔄 Creating embeddings (this may take a few minutes)...")
+    embeddings = embedding_model.encode(
+        all_chunks,
+        show_progress_bar=True,
+        convert_to_numpy=True
+    )
+    print(f"✅ Created {len(embeddings)} embeddings")
+    
+    # Create ChromaDB collection
+    print("💾 Building ChromaDB vector store...")
+    
+    # Initialize client
+    db_path = "./chroma_db"
+    client = chromadb.PersistentClient(path=db_path)
+    
+    # Delete existing collection if it exists
+    try:
+        client.delete_collection("lab_reports")
+        print("🗑️  Deleted existing collection")
+    except:
+        pass
+    
+    # Create new collection
+    collection = client.create_collection(
+        name="lab_reports",
+        metadata={"description": "Medical lab report information"}
+    )
+    
+    # Add documents in batches
+    batch_size = 100
+    for i in range(0, len(all_chunks), batch_size):
+        batch_chunks = all_chunks[i:i + batch_size]
+        batch_embeddings = embeddings[i:i + batch_size].tolist()
+        batch_ids = [f"doc_{j}" for j in range(i, i + len(batch_chunks))]
+        batch_metadata = all_metadata[i:i + batch_size]
+        
+        collection.add(
+            documents=batch_chunks,
+            embeddings=batch_embeddings,
+            ids=batch_ids,
+            metadatas=batch_metadata
+        )
+    
+    print("✅ Vector database built successfully!")
+    print(f"📍 Database location: {db_path}")
+    print(f"📊 Total vectors: {len(all_chunks)}")
+    
+    return collection
+
+def test_retrieval(collection):
+    """Test the retrieval system"""
+    if collection is None:
+        print("\n⚠️  No collection to test")
+        return
+    
+    print("\n🔍 Testing retrieval system...")
+    
+    # Load embedding model for queries
+    embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+    
+    test_queries = [
+        "What does low hemoglobin mean?",
+        "What foods are high in iron?",
+        "Normal range for glucose"
+    ]
+    
+    for query in test_queries:
+        print(f"\n📝 Query: {query}")
+        
+        # Create query embedding
+        query_embedding = embedding_model.encode(query).tolist()
+        
+        # Search
+        results = collection.query(
+            query_embeddings=[query_embedding],
+            n_results=2
+        )
+        
+        if results and results['documents']:
+            print(f"  ✅ Found {len(results['documents'][0])} relevant documents")
+            print(f"  📄 Top result preview: {results['documents'][0][0][:150]}...")
+        else:
+            print("  ❌ No results found")
+
+if __name__ == "__main__":
+    print("🚀 Building Lab Report Decoder Vector Database\n")
+    
+    # Build the database
+    collection = build_knowledge_base()
+    
+    # Test it
+    if collection:
+        test_retrieval(collection)
+        print("\n🎉 Setup complete! You can now run the Flask application.")
+    else:
+        print("\n⚠️  Please add medical documents to the data/ folder and run again.")

data/conditions/anemia.txt

@@ -0,0 +1,51 @@
+Understanding Anemia
+
+WHAT IS ANEMIA?
+Anemia occurs when you don't have enough healthy red blood cells to carry adequate oxygen to your body's tissues. This makes you feel tired and weak.
+
+TYPES OF ANEMIA:
+
+Iron-Deficiency Anemia (Most Common)
+- Causes: Not enough iron in diet, blood loss, pregnancy, poor absorption
+- Symptoms: Fatigue, weakness, pale skin, cold hands and feet, brittle nails
+- Treatment: Iron-rich diet, iron supplements, address underlying cause
+
+Vitamin Deficiency Anemia
+- Causes: Lack of vitamin B12 or folate
+- Symptoms: Similar to iron deficiency, plus numbness, balance problems
+- Treatment: Dietary changes, supplements, B12 injections if needed
+
+Anemia of Chronic Disease
+- Causes: Cancer, kidney disease, rheumatoid arthritis, Crohn's disease
+- Treatment: Treat underlying condition, may need erythropoietin therapy
+
+SYMPTOMS TO WATCH FOR:
+- Persistent fatigue and weakness
+- Pale or yellowish skin
+- Irregular heartbeat
+- Shortness of breath
+- Dizziness or lightheadedness
+- Chest pain
+- Cold hands and feet
+- Headaches
+
+WHEN TO SEE A DOCTOR:
+- Severe fatigue interfering with daily activities
+- Persistent symptoms despite dietary changes
+- Family history of inherited anemias
+- Heavy menstrual bleeding
+- Signs of internal bleeding
+
+PREVENTION:
+- Eat iron-rich foods regularly
+- Include vitamin C to help absorption
+- Don't skip meals
+- If vegetarian, plan meals carefully for adequate iron
+- Consider supplementation if at risk (pregnant women, heavy periods)
+
+LIFESTYLE TIPS:
+- Pace yourself - take breaks when tired
+- Stay hydrated
+- Avoid excessive exercise until levels improve
+- Manage stress
+- Get adequate sleep

data/lab_markers/complete_blood_count.txt

@@ -0,0 +1,42 @@
+Complete Blood Count (CBC)
+
+A Complete Blood Count measures several components of your blood to assess overall health and detect disorders.
+
+WHITE BLOOD CELLS (WBC/Leukocytes)
+Normal Range: 4,500-11,000 cells/mcL
+What it measures: White blood cells fight infections
+High WBC: May indicate infection, inflammation, leukemia, stress, or tissue damage
+Low WBC: May indicate bone marrow problems, autoimmune disorders, or certain medications
+Dietary support: Vitamin C (citrus, bell peppers), Vitamin E (nuts, seeds), zinc (shellfish, legumes)
+
+RED BLOOD CELLS (RBC/Erythrocytes)
+Normal Range: 
+- Men: 4.7-6.1 million cells/mcL
+- Women: 4.2-5.4 million cells/mcL
+What it measures: Red blood cells carry oxygen throughout your body
+High RBC: May indicate dehydration, lung disease, or polycythemia
+Low RBC: May indicate anemia, blood loss, or nutritional deficiencies
+
+HEMOGLOBIN (Hgb)
+Normal Range:
+- Men: 13.5-17.5 g/dL
+- Women: 12.0-15.5 g/dL
+What it measures: The oxygen-carrying protein in red blood cells
+High Hemoglobin: Dehydration, lung disease, smoking, high altitude
+Low Hemoglobin (Anemia): Iron deficiency, B12 deficiency, chronic disease, blood loss
+Foods to increase: Red meat, liver, spinach, lentils, fortified cereals, pumpkin seeds
+Take with Vitamin C to enhance iron absorption
+
+HEMATOCRIT (Hct)
+Normal Range:
+- Men: 38.3-48.6%
+- Women: 35.5-44.9%
+What it measures: Percentage of blood volume made up of red blood cells
+High: Dehydration, lung disease, polycythemia
+Low: Anemia, blood loss, malnutrition
+
+PLATELETS
+Normal Range: 150,000-400,000 platelets/mcL
+What it measures: Blood clotting cells
+High: May indicate inflammation, iron deficiency, or bone marrow disorders
+Low: May indicate bleeding disorders, autoimmune conditions, or certain medications

data/lab_markers/metabolic_panel.txt

@@ -0,0 +1,45 @@
+Comprehensive Metabolic Panel (CMP)
+
+GLUCOSE (Blood Sugar)
+Normal Range: 70-100 mg/dL (fasting)
+What it measures: Amount of sugar in your blood
+High (Hyperglycemia): May indicate diabetes, prediabetes, stress, or certain medications
+- Symptoms: Increased thirst, frequent urination, fatigue, blurred vision
+- Dietary changes: Reduce refined carbs, increase fiber, choose whole grains
+- Lifestyle: Regular exercise, maintain healthy weight, manage stress
+Low (Hypoglycemia): May indicate insulin overproduction or certain medications
+- Symptoms: Shakiness, sweating, confusion, hunger
+- What to do: Eat small frequent meals, balance carbs with protein
+
+CALCIUM
+Normal Range: 8.5-10.5 mg/dL
+What it measures: Calcium levels for bone health and muscle function
+High: May indicate hyperparathyroidism, certain cancers, or excess vitamin D
+Low: May indicate vitamin D deficiency, malabsorption, or kidney disease
+Foods rich in calcium: Dairy products, leafy greens, fortified plant milk, sardines with bones
+
+SODIUM
+Normal Range: 135-145 mEq/L
+What it measures: Electrolyte balance and hydration
+High: Dehydration, excess salt intake, kidney problems
+Low: Overhydration, heart failure, kidney disease, certain medications
+Balance tips: Moderate salt intake, stay hydrated, eat potassium-rich foods
+
+POTASSIUM
+Normal Range: 3.5-5.0 mEq/L
+What it measures: Electrolyte important for heart and muscle function
+High: Kidney disease, certain medications, excess supplementation
+Low: Diuretics, vomiting, diarrhea, poor diet
+Foods high in potassium: Bananas, potatoes, spinach, beans, avocados
+
+BUN (Blood Urea Nitrogen)
+Normal Range: 7-20 mg/dL
+What it measures: Kidney function
+High: Dehydration, kidney disease, high protein diet
+Low: Liver disease, malnutrition, overhydration
+
+CREATININE
+Normal Range: 0.7-1.3 mg/dL (men), 0.6-1.1 mg/dL (women)
+What it measures: Kidney function
+High: Kidney disease, dehydration, muscle injury
+Low: Low muscle mass, malnutrition

data/nutrition/iron_deficiency.txt

@@ -0,0 +1,48 @@
+Iron Deficiency and Dietary Solutions
+
+IRON-RICH FOODS
+
+Heme Iron (Better Absorbed - from animal sources):
+- Red meat (beef, lamb): 2-3 mg per 3 oz
+- Liver (beef, chicken): 5-7 mg per 3 oz
+- Oysters and clams: 8-24 mg per 3 oz
+- Sardines: 2-3 mg per 3 oz
+- Dark meat poultry: 1-2 mg per 3 oz
+
+Non-Heme Iron (from plant sources):
+- Lentils: 3 mg per 1/2 cup cooked
+- Spinach: 3 mg per 1/2 cup cooked
+- Tofu: 3 mg per 1/2 cup
+- Beans (kidney, black): 2-3 mg per 1/2 cup
+- Fortified cereals: 4-18 mg per serving
+- Pumpkin seeds: 4 mg per 1 oz
+- Quinoa: 2 mg per cup cooked
+- Dark chocolate: 3 mg per 1 oz
+
+ENHANCING IRON ABSORPTION
+
+Pair iron-rich foods with Vitamin C:
+- Citrus fruits (oranges, grapefruit, lemon)
+- Bell peppers
+- Strawberries
+- Tomatoes
+- Broccoli
+Example: Spinach salad with strawberries and orange segments
+
+FOODS THAT BLOCK IRON ABSORPTION (avoid with iron-rich meals):
+- Coffee and tea (wait 1-2 hours)
+- Dairy products (calcium competes with iron)
+- High-fiber foods in excess
+- Antacids
+
+MEAL IDEAS FOR IRON BOOST:
+Breakfast: Fortified cereal with strawberries and orange juice
+Lunch: Spinach salad with chickpeas, bell peppers, and lemon dressing
+Dinner: Lean beef with broccoli and tomato sauce
+Snack: Pumpkin seeds with dried apricots
+
+SUPPLEMENTATION TIPS:
+- Take iron supplements on an empty stomach with vitamin C
+- May cause constipation - increase fiber and water
+- Avoid taking with calcium supplements or antacids
+- Consult doctor for proper dosage

pdf_extractor.py

@@ -0,0 +1,168 @@
+"""
+PDF Extraction Module for Lab Reports
+Extracts lab test names, values, and ranges from uploaded PDF files
+"""
+
+import pdfplumber
+import re
+from typing import Dict, List, Optional
+from dataclasses import dataclass
+
+@dataclass
+class LabResult:
+    """Represents a single lab test result"""
+    test_name: str
+    value: str
+    unit: str
+    reference_range: str
+    status: str  # 'normal', 'high', 'low', 'unknown'
+
+class LabReportExtractor:
+    """Extract structured data from lab report PDFs"""
+    
+    def __init__(self):
+        # Common lab test patterns
+        self.test_patterns = [
+            r'(Hemoglobin|Hgb|Hb)\s*:?\s*([\d.]+)\s*([a-zA-Z/]+)?\s*(?:Ref\.?\s*Range:?\s*)?([\d.\-\s]+)',
+            r'(WBC|White Blood Cell|Leukocyte)\s*:?\s*([\d.]+)\s*([a-zA-Z/]+)?\s*(?:Ref\.?\s*Range:?\s*)?([\d.\-\s]+)',
+            r'(Glucose|Blood Sugar)\s*:?\s*([\d.]+)\s*([a-zA-Z/]+)?\s*(?:Ref\.?\s*Range:?\s*)?([\d.\-\s]+)',
+            r'(Iron|Ferritin)\s*:?\s*([\d.]+)\s*([a-zA-Z/]+)?\s*(?:Ref\.?\s*Range:?\s*)?([\d.\-\s]+)',
+            r'(Cholesterol|LDL|HDL)\s*:?\s*([\d.]+)\s*([a-zA-Z/]+)?\s*(?:Ref\.?\s*Range:?\s*)?([\d.\-\s]+)',
+        ]
+    
+    def extract_from_pdf(self, pdf_path: str) -> List[LabResult]:
+        """Extract lab results from PDF file"""
+        results = []
+        
+        with pdfplumber.open(pdf_path) as pdf:
+            for page in pdf.pages:
+                text = page.extract_text()
+                
+                # Try to extract tables first (more structured)
+                tables = page.extract_tables()
+                if tables:
+                    results.extend(self._parse_tables(tables))
+                
+                # Fall back to pattern matching
+                results.extend(self._parse_text(text))
+        
+        # Remove duplicates
+        unique_results = self._deduplicate_results(results)
+        
+        return unique_results
+    
+    def _parse_tables(self, tables: List) -> List[LabResult]:
+        """Parse lab results from extracted tables"""
+        results = []
+        
+        for table in tables:
+            if not table or len(table) < 2:
+                continue
+            
+            # Assume first row is header
+            headers = [h.lower() if h else '' for h in table[0]]
+            
+            # Find relevant columns
+            test_col = self._find_column(headers, ['test', 'name', 'component'])
+            value_col = self._find_column(headers, ['value', 'result'])
+            unit_col = self._find_column(headers, ['unit', 'units'])
+            range_col = self._find_column(headers, ['range', 'reference', 'normal'])
+            
+            # Parse data rows
+            for row in table[1:]:
+                if not row or len(row) <= max(test_col or 0, value_col or 0):
+                    continue
+                
+                test_name = row[test_col] if test_col is not None else ''
+                value = row[value_col] if value_col is not None else ''
+                unit = row[unit_col] if unit_col is not None else ''
+                ref_range = row[range_col] if range_col is not None else ''
+                
+                if test_name and value:
+                    status = self._determine_status(value, ref_range)
+                    results.append(LabResult(
+                        test_name=test_name.strip(),
+                        value=str(value).strip(),
+                        unit=str(unit).strip() if unit else '',
+                        reference_range=str(ref_range).strip() if ref_range else '',
+                        status=status
+                    ))
+        
+        return results
+    
+    def _parse_text(self, text: str) -> List[LabResult]:
+        """Parse lab results using regex patterns"""
+        results = []
+        
+        for pattern in self.test_patterns:
+            matches = re.finditer(pattern, text, re.IGNORECASE)
+            for match in matches:
+                groups = match.groups()
+                if len(groups) >= 2:
+                    test_name = groups[0]
+                    value = groups[1]
+                    unit = groups[2] if len(groups) > 2 else ''
+                    ref_range = groups[3] if len(groups) > 3 else ''
+                    
+                    status = self._determine_status(value, ref_range)
+                    results.append(LabResult(
+                        test_name=test_name,
+                        value=value,
+                        unit=unit or '',
+                        reference_range=ref_range or '',
+                        status=status
+                    ))
+        
+        return results
+    
+    def _find_column(self, headers: List[str], keywords: List[str]) -> Optional[int]:
+        """Find column index by keywords"""
+        for i, header in enumerate(headers):
+            for keyword in keywords:
+                if keyword in header:
+                    return i
+        return None
+    
+    def _determine_status(self, value: str, ref_range: str) -> str:
+        """Determine if value is normal, high, or low"""
+        try:
+            val = float(value.replace(',', ''))
+            
+            # Parse reference range
+            range_match = re.search(r'([\d.]+)\s*-\s*([\d.]+)', ref_range)
+            if range_match:
+                low = float(range_match.group(1))
+                high = float(range_match.group(2))
+                
+                if val < low:
+                    return 'low'
+                elif val > high:
+                    return 'high'
+                else:
+                    return 'normal'
+        except (ValueError, AttributeError):
+            pass
+        
+        return 'unknown'
+    
+    def _deduplicate_results(self, results: List[LabResult]) -> List[LabResult]:
+        """Remove duplicate test results"""
+        seen = set()
+        unique = []
+        
+        for result in results:
+            key = (result.test_name.lower(), result.value)
+            if key not in seen:
+                seen.add(key)
+                unique.append(result)
+        
+        return unique
+
+# Example usage
+if __name__ == "__main__":
+    extractor = LabReportExtractor()
+    results = extractor.extract_from_pdf("sample_lab_report.pdf")
+    
+    for result in results:
+        print(f"{result.test_name}: {result.value} {result.unit} [{result.status}]")
+        print(f"  Reference: {result.reference_range}")

rag_engine.py

@@ -0,0 +1,253 @@
+"""
+RAG Query Engine for Lab Report Decoder
+Uses Hugging Face models for embeddings and generation
+"""
+
+from sentence_transformers import SentenceTransformer
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+import chromadb
+from chromadb.config import Settings
+from typing import List, Dict
+from pdf_extractor import LabResult
+import torch
+
+class LabReportRAG:
+    """RAG system for explaining lab results using Hugging Face models"""
+    
+    def __init__(self, db_path: str = "./chroma_db"):
+        """Initialize the RAG system with Hugging Face models"""
+        
+        print("🔄 Loading Hugging Face models...")
+        
+        # Use smaller, faster models for embeddings
+        self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        # Use a medical-focused or general LLM
+        # Options: 
+        # - "microsoft/Phi-3-mini-4k-instruct" (good balance)
+        # - "google/flan-t5-base" (lighter)
+        # - "meta-llama/Llama-2-7b-chat-hf" (requires auth)
+        
+        model_name = "microsoft/Phi-3-mini-4k-instruct"
+        
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+            self.llm = AutoModelForCausalLM.from_pretrained(
+                model_name,
+                trust_remote_code=True,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None
+            )
+            print(f"✅ Loaded model: {model_name}")
+        except Exception as e:
+            print(f"⚠️ Could not load {model_name}, falling back to simpler model")
+            # Fallback to lighter model
+            self.text_generator = pipeline(
+                "text-generation",
+                model="google/flan-t5-base",
+                max_length=512
+            )
+            self.llm = None
+        
+        # Load vector store
+        try:
+            self.client = chromadb.PersistentClient(path=db_path)
+            self.collection = self.client.get_collection("lab_reports")
+            print("✅ Vector database loaded")
+        except Exception as e:
+            print(f"⚠️ No vector database found. Please run build_vector_db.py first.")
+            self.collection = None
+    
+    def _generate_with_phi(self, prompt: str, max_tokens: int = 512) -> str:
+        """Generate text using Phi-3 model"""
+        inputs = self.tokenizer(prompt, return_tensors="pt", truncation=True, max_length=2048)
+        
+        if torch.cuda.is_available():
+            inputs = {k: v.to('cuda') for k, v in inputs.items()}
+        
+        outputs = self.llm.generate(
+            **inputs,
+            max_new_tokens=max_tokens,
+            temperature=0.7,
+            do_sample=True,
+            top_p=0.9
+        )
+        
+        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        # Remove the prompt from response
+        response = response.replace(prompt, "").strip()
+        return response
+    
+    def _generate_with_fallback(self, prompt: str) -> str:
+        """Generate text using fallback pipeline"""
+        result = self.text_generator(prompt, max_length=512, num_return_sequences=1)
+        return result[0]['generated_text']
+    
+    def _generate_text(self, prompt: str) -> str:
+        """Generate text using available model"""
+        try:
+            if self.llm is not None:
+                return self._generate_with_phi(prompt)
+            else:
+                return self._generate_with_fallback(prompt)
+        except Exception as e:
+            print(f"Generation error: {e}")
+            return "Sorry, I encountered an error generating the explanation."
+    
+    def _retrieve_context(self, query: str, k: int = 3) -> str:
+        """Retrieve relevant context from vector database"""
+        if self.collection is None:
+            return "No medical reference data available."
+        
+        try:
+            # Create query embedding
+            query_embedding = self.embedding_model.encode(query).tolist()
+            
+            # Query the collection
+            results = self.collection.query(
+                query_embeddings=[query_embedding],
+                n_results=k
+            )
+            
+            # Combine documents
+            if results and results['documents']:
+                context = "\n\n".join(results['documents'][0])
+                return context
+            else:
+                return "No relevant information found."
+        except Exception as e:
+            print(f"Retrieval error: {e}")
+            return "Error retrieving medical information."
+    
+    def explain_result(self, result: LabResult) -> str:
+        """Generate explanation for a single lab result"""
+        
+        # Retrieve relevant context
+        query = f"{result.test_name} {result.status} meaning causes treatment"
+        context = self._retrieve_context(query, k=3)
+        
+        # Create prompt
+        prompt = f"""You are a helpful medical assistant. Explain this lab result in simple terms.
+
+Medical Information:
+{context}
+
+Lab Test: {result.test_name}
+Value: {result.value} {result.unit}
+Reference Range: {result.reference_range}
+Status: {result.status}
+
+Please explain:
+1. What this test measures
+2. What this result means
+3. Possible causes if abnormal
+4. Dietary recommendations if applicable
+
+Keep it simple and clear. Answer:"""
+
+        # Generate explanation
+        explanation = self._generate_text(prompt)
+        
+        return explanation
+    
+    def explain_all_results(self, results: List[LabResult]) -> Dict[str, str]:
+        """Generate explanations for all lab results"""
+        explanations = {}
+        
+        for result in results:
+            print(f"Explaining {result.test_name}...")
+            explanation = self.explain_result(result)
+            explanations[result.test_name] = explanation
+        
+        return explanations
+    
+    def answer_followup_question(self, question: str, lab_results: List[LabResult]) -> str:
+        """Answer follow-up questions about lab results"""
+        
+        # Create context from lab results
+        results_context = "\n".join([
+            f"{r.test_name}: {r.value} {r.unit} (Status: {r.status}, Range: {r.reference_range})"
+            for r in lab_results
+        ])
+        
+        # Retrieve relevant medical information
+        medical_context = self._retrieve_context(question, k=3)
+        
+        # Create prompt
+        prompt = f"""You are a medical assistant. Answer this question based on the patient's lab results and medical information.
+
+Patient's Lab Results:
+{results_context}
+
+Medical Information:
+{medical_context}
+
+Question: {question}
+
+Provide a clear, helpful answer. Answer:"""
+        
+        # Generate answer
+        answer = self._generate_text(prompt)
+        
+        return answer
+    
+    def generate_summary(self, results: List[LabResult]) -> str:
+        """Generate overall summary of lab results"""
+        
+        abnormal = [r for r in results if r.status in ['high', 'low']]
+        normal = [r for r in results if r.status == 'normal']
+        
+        if not abnormal:
+            return "✅ Great news! All your lab results are within normal ranges. Keep up the good work with your health!"
+        
+        # Get context about abnormal results
+        queries = [f"{r.test_name} {r.status}" for r in abnormal]
+        combined_query = " ".join(queries)
+        context = self._retrieve_context(combined_query, k=4)
+        
+        # Create summary prompt
+        abnormal_list = "\n".join([
+            f"- {r.test_name}: {r.value} {r.unit} ({r.status})"
+            for r in abnormal
+        ])
+        
+        prompt = f"""Provide a brief summary of these lab results.
+
+Normal Results: {len(normal)} tests
+Abnormal Results: {len(abnormal)} tests
+
+Abnormal Tests:
+{abnormal_list}
+
+Medical Context:
+{context}
+
+Write a 2-3 paragraph summary explaining what these results mean overall and general recommendations. Be reassuring but honest. Summary:"""
+        
+        # Generate summary
+        summary = self._generate_text(prompt)
+        
+        return summary
+
+
+# Example usage
+if __name__ == "__main__":
+    from pdf_extractor import LabResult
+    
+    # Initialize RAG system
+    print("Initializing RAG system...")
+    rag = LabReportRAG()
+    
+    # Example result
+    test_result = LabResult(
+        test_name="Hemoglobin",
+        value="10.5",
+        unit="g/dL",
+        reference_range="12.0-15.5",
+        status="low"
+    )
+    
+    # Generate explanation
+    print("\nGenerating explanation...")
+    explanation = rag.explain_result(test_result)
+    print(f"\n{explanation}")

static/script.js

@@ -0,0 +1,385 @@
+// ===== GLOBAL STATE =====
+let currentResults = null;
+let explanations = null;
+
+// ===== INITIALIZATION =====
+document.addEventListener('DOMContentLoaded', () => {
+    // Navigation is now handled via onclick="showSection", but we init other listeners
+    initFileUpload();
+    initScrollAnimations();
+    initEnterKey();
+});
+
+// ===== NAVIGATION (Compatible with Tailwind HTML) =====
+function showSection(sectionId) {
+    // Hide all sections
+    document.querySelectorAll('.section').forEach(sec => {
+        sec.classList.remove('active');
+        sec.style.display = 'none';
+    });
+
+    // Show target section
+    const target = document.getElementById(sectionId);
+    if (target) {
+        target.style.display = 'block';
+        // Small timeout to allow display:block to apply before adding active class for animation
+        setTimeout(() => {
+            target.classList.add('active');
+        }, 10);
+        
+        // Scroll to top
+        window.scrollTo({ top: 0, behavior: 'smooth' });
+    }
+}
+
+// ===== SCROLL ANIMATIONS =====
+function initScrollAnimations() {
+    const observer = new IntersectionObserver((entries) => {
+        entries.forEach(entry => {
+            if (entry.isIntersecting) {
+                entry.target.classList.remove('opacity-0', 'translate-y-4');
+                entry.target.classList.add('opacity-100', 'translate-y-0');
+            }
+        });
+    }, { threshold: 0.1 });
+    
+    // Add animation classes to cards
+    document.querySelectorAll('.feature-card, .upload-card').forEach(card => {
+        card.classList.add('transition-all', 'duration-700', 'opacity-0', 'translate-y-4');
+        observer.observe(card);
+    });
+}
+
+// ===== FILE UPLOAD =====
+function initFileUpload() {
+    const fileInput = document.getElementById('fileInput');
+    const uploadArea = document.getElementById('uploadArea');
+    
+    if (!fileInput || !uploadArea) return;
+    
+    // Click to upload (handled by onclick in HTML, but keeping listener just in case)
+    fileInput.addEventListener('change', handleFileSelect);
+    
+    // Drag and drop Visuals
+    uploadArea.addEventListener('dragover', (e) => {
+        e.preventDefault();
+        // Add Tailwind classes for drag state
+        uploadArea.classList.add('border-secondary', 'bg-blue-50', 'scale-[1.02]');
+    });
+    
+    uploadArea.addEventListener('dragleave', () => {
+        // Remove Tailwind classes
+        uploadArea.classList.remove('border-secondary', 'bg-blue-50', 'scale-[1.02]');
+    });
+    
+    uploadArea.addEventListener('drop', (e) => {
+        e.preventDefault();
+        uploadArea.classList.remove('border-secondary', 'bg-blue-50', 'scale-[1.02]');
+        
+        const file = e.dataTransfer.files[0];
+        if (file && file.type === 'application/pdf') {
+            uploadFile(file);
+        } else {
+            showToast('Please upload a PDF file', 'error');
+        }
+    });
+}
+
+function handleFileSelect(e) {
+    const file = e.target.files[0];
+    if (file) {
+        uploadFile(file);
+    }
+}
+
+async function uploadFile(file) {
+    const formData = new FormData();
+    formData.append('file', file);
+    
+    // Show progress
+    document.getElementById('uploadArea').classList.add('hidden');
+    document.getElementById('uploadProgress').classList.remove('hidden');
+    
+    try {
+        const response = await fetch('/api/upload', {
+            method: 'POST',
+            body: formData
+        });
+        
+        const data = await response.json();
+        
+        if (!response.ok) {
+            throw new Error(data.error || 'Upload failed');
+        }
+        
+        currentResults = data.results;
+        showToast(`✓ Found ${data.count} lab results!`, 'success');
+        
+        // Generate explanations
+        await generateExplanations();
+        
+        // Display results
+        displayResults();
+        
+        // Switch to results tab automatically
+        showSection('results-section');
+        
+    } catch (error) {
+        showToast(error.message, 'error');
+        resetUploadArea();
+    }
+}
+
+async function generateExplanations() {
+    // Optional: show a mini toast or loading indicator
+    try {
+        const response = await fetch('/api/explain', { method: 'POST' });
+        const data = await response.json();
+        if (!response.ok) throw new Error(data.error);
+        explanations = data.explanations;
+    } catch (error) {
+        console.warn('Auto-explanation generation failed:', error);
+        // We continue anyway, results will just say "Loading..." or show basic info
+    }
+}
+
+function displayResults() {
+    const container = document.getElementById('resultsContainer');
+    
+    if (!currentResults || currentResults.length === 0) {
+        container.innerHTML = '<div class="text-center text-gray-500 py-10">No results found</div>';
+        return;
+    }
+    
+    // Update summary stats in the Summary tab
+    updateSummaryStats();
+    
+    // Clear container
+    container.innerHTML = '';
+    
+    // Create result cards with Tailwind Styling
+    currentResults.forEach((result, index) => {
+        const card = createResultCard(result, index);
+        container.appendChild(card);
+    });
+    
+    // Reset upload area for next time
+    resetUploadArea();
+}
+
+function updateSummaryStats() {
+    const stats = { normal: 0, high: 0, low: 0 };
+    
+    currentResults.forEach(result => {
+        // Normalize status string
+        const status = result.status ? result.status.toLowerCase() : 'normal';
+        if (status.includes('high')) stats.high++;
+        else if (status.includes('low')) stats.low++;
+        else stats.normal++;
+    });
+    
+    // Update the DOM elements in the Summary Section
+    document.getElementById('normalCount').textContent = stats.normal;
+    document.getElementById('highCount').textContent = stats.high;
+    document.getElementById('lowCount').textContent = stats.low;
+    
+    // Reveal the stats container
+    const statsContainer = document.getElementById('summaryStats');
+    if(statsContainer) statsContainer.classList.remove('hidden');
+    
+    const generateBtn = document.getElementById('generateSummaryBtn');
+    if(generateBtn) generateBtn.classList.remove('hidden');
+}
+
+function createResultCard(result, index) {
+    const card = document.createElement('div');
+    // TAILWIND STYLING: Card container
+    card.className = 'bg-white rounded-xl shadow-sm border border-slate-100 p-5 mb-4 hover:shadow-md transition-shadow';
+    
+    // Status colors
+    let statusColors = 'bg-green-100 text-green-700'; // Default normal
+    let borderClass = 'border-l-4 border-green-500';
+    
+    const statusLower = result.status ? result.status.toLowerCase() : '';
+    if (statusLower.includes('high')) {
+        statusColors = 'bg-red-100 text-red-700';
+        borderClass = 'border-l-4 border-red-500';
+    } else if (statusLower.includes('low')) {
+        statusColors = 'bg-yellow-100 text-yellow-800';
+        borderClass = 'border-l-4 border-yellow-500';
+    }
+
+    const explanation = explanations && explanations[result.test_name] 
+        ? explanations[result.test_name] 
+        : 'Analysis available in Chat or Summary.';
+    
+    // HTML Structure using Tailwind
+    card.innerHTML = `
+        <div class="flex flex-col md:flex-row justify-between items-start md:items-center gap-4 ${borderClass} pl-4">
+            <div class="flex-grow">
+                <h3 class="text-lg font-bold text-slate-800">${escapeHtml(result.test_name)}</h3>
+                <p class="text-sm text-slate-500">Ref Range: ${escapeHtml(result.reference_range || 'N/A')}</p>
+            </div>
+            
+            <div class="flex items-center gap-3 w-full md:w-auto justify-between md:justify-end">
+                <span class="text-xl font-bold text-slate-700">${escapeHtml(result.value)} <span class="text-sm font-normal text-slate-500">${escapeHtml(result.unit)}</span></span>
+                <span class="px-3 py-1 rounded-full text-xs font-bold uppercase tracking-wide ${statusColors}">
+                    ${escapeHtml(result.status)}
+                </span>
+            </div>
+        </div>
+        
+        <div class="mt-4 pt-3 border-t border-slate-50">
+            <p class="text-sm text-slate-600 leading-relaxed">
+                <span class="font-semibold text-primary">Insight:</span> ${escapeHtml(explanation)}
+            </p>
+        </div>
+    `;
+    
+    return card;
+}
+
+function resetUploadArea() {
+    document.getElementById('uploadArea').classList.remove('hidden');
+    document.getElementById('uploadProgress').classList.add('hidden');
+    document.getElementById('fileInput').value = '';
+}
+
+// ===== SUMMARY GENERATION =====
+async function generateSummary() {
+    if (!currentResults) {
+        showToast('Please upload a lab report first', 'error');
+        return;
+    }
+    
+    const contentDiv = document.getElementById('summaryContent');
+    contentDiv.innerHTML = '<div class="flex justify-center p-8"><div class="animate-spin rounded-full h-8 w-8 border-b-2 border-primary"></div></div>';
+    
+    try {
+        const response = await fetch('/api/summary');
+        const data = await response.json();
+        
+        if (!response.ok) throw new Error(data.error);
+        
+        // Render summary with Markdown-like paragraphs
+        contentDiv.innerHTML = `
+            <div class="prose prose-slate max-w-none">
+                <h3 class="text-xl font-semibold mb-4 text-primary">Analysis Report</h3>
+                <div class="text-slate-700 leading-relaxed whitespace-pre-line">
+                    ${escapeHtml(data.summary).replace(/\n/g, '<br>')}
+                </div>
+            </div>
+        `;
+        
+    } catch (error) {
+        showToast('Error: ' + error.message, 'error');
+        contentDiv.innerHTML = '<p class="text-red-500 text-center">Failed to generate summary.</p>';
+    }
+}
+
+// ===== CHAT FUNCTIONALITY =====
+function initEnterKey() {
+    const input = document.getElementById('chatInput');
+    if (input) {
+        input.addEventListener('keypress', (e) => {
+            if (e.key === 'Enter') askQuestion();
+        });
+    }
+}
+
+async function askQuestion() {
+    if (!currentResults) {
+        showToast('Please upload a lab report first', 'error');
+        return;
+    }
+
+    const input = document.getElementById('chatInput');
+    const question = input.value.trim();
+    
+    if (!question) return;
+    
+    // Clear input
+    input.value = '';
+    
+    // Add user message
+    addChatMessage(question, 'user');
+    
+    // Show loading
+    const loadingId = addChatMessage('Analyzing...', 'assistant', true);
+    
+    try {
+        const response = await fetch('/api/ask', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ question })
+        });
+        
+        const data = await response.json();
+        if (!response.ok) throw new Error(data.error);
+        
+        // Remove loading
+        const loadingEl = document.getElementById(loadingId);
+        if(loadingEl) loadingEl.remove();
+        
+        // Add response
+        addChatMessage(data.answer, 'assistant');
+        
+    } catch (error) {
+        const loadingEl = document.getElementById(loadingId);
+        if(loadingEl) loadingEl.remove();
+        showToast(error.message, 'error');
+    }
+}
+
+function addChatMessage(text, sender, isLoading = false) {
+    const container = document.getElementById('chatMessages');
+    
+    const wrapper = document.createElement('div');
+    // Flex alignment based on sender
+    wrapper.className = `flex w-full mb-4 ${sender === 'user' ? 'justify-end' : 'justify-start'}`;
+    
+    const bubble = document.createElement('div');
+    // Bubble Styling
+    const baseStyle = "max-w-[85%] rounded-2xl px-5 py-3 shadow-sm text-sm leading-relaxed";
+    const userStyle = "bg-secondary text-white rounded-br-none"; // Blue bubble
+    const aiStyle = "bg-slate-100 text-slate-800 rounded-tl-none border border-slate-200"; // Grey bubble
+    
+    bubble.className = `${baseStyle} ${sender === 'user' ? userStyle : aiStyle} ${isLoading ? 'animate-pulse' : ''}`;
+    
+    bubble.innerHTML = escapeHtml(text).replace(/\n/g, '<br>');
+    if (isLoading) bubble.id = `loading-${Date.now()}`;
+    
+    wrapper.appendChild(bubble);
+    container.appendChild(wrapper);
+    
+    // Scroll to bottom
+    container.scrollTop = container.scrollHeight;
+    
+    return bubble.id;
+}
+
+// ===== TOAST NOTIFICATIONS =====
+function showToast(message, type = 'info') {
+    const toast = document.getElementById('toast');
+    toast.textContent = message;
+    
+    // Tailwind classes for toast
+    toast.className = `fixed bottom-5 right-5 px-6 py-3 rounded-lg shadow-2xl transform transition-all duration-300 z-50 text-white font-medium translate-y-0 opacity-100`;
+    
+    if (type === 'error') toast.classList.add('bg-red-600');
+    else if (type === 'success') toast.classList.add('bg-green-600');
+    else toast.classList.add('bg-slate-800');
+    
+    setTimeout(() => {
+        toast.classList.remove('translate-y-0', 'opacity-100');
+        toast.classList.add('translate-y-20', 'opacity-0');
+    }, 4000);
+}
+
+// ===== UTILS =====
+function escapeHtml(text) {
+    if (!text) return '';
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}

static/style.css

@@ -0,0 +1,32 @@
+/* We are moving the styling to the HTML. 
+   This file now only handles the visibility logic. */
+
+.section {
+    display: none; /* Hide all sections by default */
+    animation: fadeIn 0.3s ease-in-out;
+}
+
+.section.active {
+    display: block; /* Only show the active section */
+}
+
+/* Smooth fade in animation */
+@keyframes fadeIn {
+    from { opacity: 0; transform: translateY(10px); }
+    to { opacity: 1; transform: translateY(0); }
+}
+
+/* Custom scrollbar for chat */
+.chat-messages::-webkit-scrollbar {
+    width: 6px;
+}
+.chat-messages::-webkit-scrollbar-track {
+    background: #f1f1f1; 
+}
+.chat-messages::-webkit-scrollbar-thumb {
+    background: #cbd5e1; 
+    border-radius: 3px;
+}
+.chat-messages::-webkit-scrollbar-thumb:hover {
+    background: #94a3b8; 
+}

templates/index.html

@@ -0,0 +1,322 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Lab Report Decoder - AI-Powered Medical Analysis</title>
+
+    <!-- Load Tailwind CSS -->
+    <script src="https://cdn.tailwindcss.com"></script>
+
+    <!-- Link to our simple CSS for toggling sections -->
+    <link
+      rel="stylesheet"
+      href="{{ url_for('static', filename='css/styley.css') }}"
+    />
+
+    <!-- Font -->
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
+
+    <!-- Configure Tailwind Colors -->
+    <script>
+      tailwind.config = {
+        theme: {
+          extend: {
+            colors: {
+              primary: "#659BB9" /* Deep Blue */,
+              secondary: "rgb(51 99 176)" /* Bright Blue */,
+              surface: "#ffffff" /* White */,
+              background: "#f8fafc" /* Very Light Blue-Grey */,
+            },
+            fontFamily: {
+              sans: ["Inter", "sans-serif"],
+            },
+          },
+        },
+      };
+    </script>
+  </head>
+  <body class="bg-background font-sans text-slate-800 h-screen flex flex-col">
+    <!-- Header -->
+    <header class="bg-primary text-white shadow-lg sticky top-0 z-50">
+      <div class="max-w-6xl mx-auto px-4 sm:px-6 lg:px-8">
+        <div class="flex items-center justify-between h-16">
+          <!-- Logo -->
+          <div
+            class="flex items-center space-x-3 cursor-pointer"
+            onclick="showSection('upload-section')"
+          >
+            <span class="text-2xl">🔬</span>
+            <span class="font-bold text-xl tracking-tight"
+              >Lab Report Decoder</span
+            >
+          </div>
+
+          <!-- Navigation -->
+          <nav class="hidden md:flex space-x-1">
+            <button
+              onclick="showSection('upload-section')"
+              class="nav-btn px-4 py-2 rounded-lg text-sm font-medium hover:bg-white/10 transition-colors text-white/90 hover:text-white"
+            >
+              Upload
+            </button>
+            <button
+              onclick="showSection('results-section')"
+              class="nav-btn px-4 py-2 rounded-lg text-sm font-medium hover:bg-white/10 transition-colors text-white/90 hover:text-white"
+            >
+              Results
+            </button>
+            <button
+              onclick="showSection('chat-section')"
+              class="nav-btn px-4 py-2 rounded-lg text-sm font-medium hover:bg-white/10 transition-colors text-white/90 hover:text-white"
+            >
+              Ask Questions
+            </button>
+            <button
+              onclick="showSection('summary-section')"
+              class="nav-btn px-4 py-2 rounded-lg text-sm font-medium hover:bg-white/10 transition-colors text-white/90 hover:text-white"
+            >
+              Summary
+            </button>
+          </nav>
+        </div>
+      </div>
+    </header>
+
+    <!-- Main Content -->
+    <main class="flex-grow max-w-5xl w-full mx-auto px-4 sm:px-6 py-12">
+      <!-- SECTION 1: UPLOAD (Default Active) -->
+      <div id="upload-section" class="section active space-y-8">
+        <!-- Hero Text -->
+        <div class="text-center max-w-2xl mx-auto mb-10">
+          <h1 class="text-4xl font-extrabold text-primary mb-4 tracking-tight">
+            Understand Your Lab Results
+          </h1>
+          <p class="text-lg text-slate-500">
+            Upload your PDF report and get plain English explanations, dietary
+            advice, and AI-powered insights.
+          </p>
+        </div>
+
+        <!-- Upload Card -->
+        <div
+          class="bg-surface rounded-2xl shadow-xl border border-slate-100 p-10 max-w-3xl mx-auto transition-transform hover:scale-[1.01] duration-300"
+        >
+          <div
+            class="upload-area group border-2 border-dashed border-blue-200 bg-blue-50/50 rounded-xl p-12 text-center hover:border-secondary hover:bg-blue-50 transition-all cursor-pointer"
+            id="uploadArea"
+            onclick="document.getElementById('fileInput').click()"
+          >
+            <div
+              class="text-5xl mb-4 group-hover:scale-110 transition-transform duration-300"
+            >
+              📄
+            </div>
+            <h3 class="text-xl font-semibold text-slate-700 mb-2">
+              Drop your lab report PDF here
+            </h3>
+            <p class="text-slate-500 text-sm mb-6">
+              or click to browse (Max 16MB)
+            </p>
+
+            <input type="file" id="fileInput" accept=".pdf" hidden />
+
+            <button
+              class="bg-secondary text-white px-8 py-3 rounded-full font-medium shadow-md shadow-blue-500/30 hover:bg-blue-600 hover:shadow-blue-500/40 transition-all transform hover:-translate-y-0.5"
+            >
+              Choose File
+            </button>
+          </div>
+
+          <!-- Progress Indicator (Hidden by default) -->
+          <div id="uploadProgress" class="hidden mt-8 text-center">
+            <div
+              class="inline-block animate-spin rounded-full h-8 w-8 border-4 border-blue-200 border-t-secondary"
+            ></div>
+            <p class="text-secondary font-medium mt-3 animate-pulse">
+              Analyzing your report...
+            </p>
+          </div>
+        </div>
+
+        <!-- Features Grid -->
+        <div class="grid md:grid-cols-3 gap-6 max-w-4xl mx-auto mt-12">
+          <div
+            class="bg-surface p-6 rounded-xl shadow-sm border border-slate-100 hover:shadow-md transition-shadow"
+          >
+            <div class="text-3xl mb-3">🔍</div>
+            <h3 class="font-semibold text-slate-800">Automatic Extraction</h3>
+            <p class="text-sm text-slate-500 mt-1">
+              Extracts all test values instantly
+            </p>
+          </div>
+          <div
+            class="bg-surface p-6 rounded-xl shadow-sm border border-slate-100 hover:shadow-md transition-shadow"
+          >
+            <div class="text-3xl mb-3">🧠</div>
+            <h3 class="font-semibold text-slate-800">AI Analysis</h3>
+            <p class="text-sm text-slate-500 mt-1">
+              Medical-grade explanations
+            </p>
+          </div>
+          <div
+            class="bg-surface p-6 rounded-xl shadow-sm border border-slate-100 hover:shadow-md transition-shadow"
+          >
+            <div class="text-3xl mb-3">🍎</div>
+            <h3 class="font-semibold text-slate-800">Dietary Tips</h3>
+            <p class="text-sm text-slate-500 mt-1">
+              Personalized nutrition advice
+            </p>
+          </div>
+        </div>
+      </div>
+
+      <!-- SECTION 2: RESULTS -->
+      <div id="results-section" class="section space-y-8 mt-12">
+        <h2 class="text-2xl font-bold text-slate-800 mb-6 flex items-center">
+          <span class="bg-blue-100 text-blue-600 p-2 rounded-lg mr-3 text-xl"
+            >📋</span
+          >
+          Your Results
+        </h2>
+        <div
+          id="resultsContainer"
+          class="bg-surface rounded-xl shadow-lg border border-slate-100 min-h-[400px] p-6"
+        >
+          <div
+            class="flex flex-col items-center justify-center h-full text-slate-400 py-20"
+          >
+            <div class="text-6xl mb-4 opacity-20">📊</div>
+            <p>Upload a lab report to view results here</p>
+          </div>
+        </div>
+      </div>
+
+      <!-- SECTION 3: CHAT -->
+      <div id="chat-section" class="section space-y-8 mt-12">
+        <div
+          class="flex flex-col h-full bg-surface rounded-xl shadow-lg border border-slate-100 overflow-hidden"
+        >
+          <div class="bg-slate-50 border-b border-slate-100 p-4">
+            <h2 class="font-bold text-slate-700">Ask Questions</h2>
+            <p class="text-xs text-slate-500">
+              Ask about your specific values, diet, or lifestyle.
+            </p>
+          </div>
+
+          <!-- Chat Area -->
+          <div
+            id="chatMessages"
+            class="flex-grow overflow-y-auto p-6 space-y-8 bg-white"
+          >
+            <div class="text-center text-slate-400 py-10">
+              <p class="mb-4">Try asking:</p>
+              <div class="inline-flex flex-col gap-2 text-sm text-blue-600">
+                <span
+                  class="bg-blue-50 px-3 py-1 rounded-full cursor-pointer hover:bg-blue-100"
+                  >"Is my cholesterol dangerous?"</span
+                >
+                <span
+                  class="bg-blue-50 px-3 py-1 rounded-full cursor-pointer hover:bg-blue-100"
+                  >"What foods lower iron?"</span
+                >
+              </div>
+            </div>
+          </div>
+
+          <!-- Input Area -->
+          <div class="p-4 border-t border-slate-100 bg-slate-50">
+            <div class="flex gap-2">
+              <input
+                type="text"
+                id="chatInput"
+                class="flex-grow px-4 py-3 rounded-xl border border-slate-300 focus:border-secondary focus:ring-2 focus:ring-blue-100 outline-none transition-all"
+                placeholder="Type your medical question..."
+              />
+              <button
+                onclick="askQuestion()"
+                class="bg-secondary text-white px-6 rounded-xl font-medium hover:bg-blue-600 transition-colors shadow-sm"
+              >
+                Send
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <!-- SECTION 4: SUMMARY -->
+      <div id="summary-section" class="section mt-12">
+        <h2 class="text-2xl font-bold text-slate-800 mb-6 flex items-center">
+          <span
+            class="bg-purple-100 text-purple-600 p-2 rounded-lg mr-3 text-xl"
+            >📝</span
+          >
+          Health Summary
+        </h2>
+
+        <!-- Stats Row -->
+        <div id="summaryStats" class="grid grid-cols-3 gap-4 mb-6 hidden">
+          <div class="bg-green-50 p-4 rounded-xl border border-green-100">
+            <div class="text-3xl font-bold text-green-600" id="normalCount">
+              0
+            </div>
+            <div class="text-sm text-green-700 font-medium">Normal Ranges</div>
+          </div>
+          <div class="bg-red-50 p-4 rounded-xl border border-red-100">
+            <div class="text-3xl font-bold text-red-600" id="highCount">0</div>
+            <div class="text-sm text-red-700 font-medium">High Values</div>
+          </div>
+          <div class="bg-yellow-50 p-4 rounded-xl border border-yellow-100">
+            <div class="text-3xl font-bold text-yellow-600" id="lowCount">
+              0
+            </div>
+            <div class="text-sm text-yellow-700 font-medium">Low Values</div>
+          </div>
+        </div>
+
+        <div
+          id="summaryContent"
+          class="bg-surface rounded-xl shadow-lg border border-slate-100 p-8 min-h-[200px]"
+        >
+          <div class="text-center text-slate-400 py-10">
+            <p>Analysis summary will appear here after upload</p>
+          </div>
+        </div>
+
+        <button
+          id="generateSummaryBtn"
+          onclick="generateSummary()"
+          class="hidden mt-6 w-full py-3 bg-white border-2 border-secondary text-secondary font-bold rounded-xl hover:bg-blue-50 transition-colors"
+        >
+          Regenerate Detailed Summary
+        </button>
+      </div>
+    </main>
+
+    <!-- Footer -->
+    <footer class="bg-white border-t border-slate-200 py-6 mt-20">
+      <div class="max-w-4xl mx-auto text-center px-4">
+        <p
+          class="text-sm text-red-500 font-medium bg-red-50 inline-block px-4 py-1 rounded-full mb-2"
+        >
+          ⚠️ Educational Purpose Only - Not Medical Advice
+        </p>
+        <p class="text-xs text-slate-400">
+          Always consult a professional healthcare provider for diagnosis and
+          treatment.
+        </p>
+      </div>
+    </footer>
+
+    <!-- Toast Notification -->
+    <div
+      id="toast"
+      class="fixed bottom-5 right-5 bg-slate-800 text-white px-6 py-3 rounded-lg shadow-2xl transform translate-y-20 opacity-0 transition-all duration-300 z-50"
+    ></div>
+
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+  </body>
+</html>