reverting

src/model.py

@@ -1,1148 +1,310 @@
-import requests
+import streamlit as st
 import uuid
-import json
-import re
-import xml.etree.ElementTree as ET
-from bs4 import BeautifulSoup
 from datetime import datetime
+import json
 import os
-import openai
-import urllib.parse
-from dotenv import load_dotenv
-
-# Load environment variables
-load_dotenv()
-
-# Initialize OpenAI API key
-def get_openai_api_key():
-    """Get OpenAI API key from environment variables"""
-    api_key = os.environ.get("OPENAI_API_KEY")
-    if not api_key:
-        raise ValueError("OPENAI_API_KEY environment variable is not set")
-    return api_key
-
-# Set OpenAI API key
-openai.api_key = get_openai_api_key()
-
-# System prompts
-SYSTEM_PROMPT = """You are an advanced clinical AI assistant designed to aid healthcare professionals.
-Follow these guidelines in all responses:
-
-1.  **Clarify First**: Before providing any diagnosis or plan, if the user's query is underspecified, ALWAYS ask relevant clarifying questions to gather necessary patient information. This includes, but is not limited to, symptoms, duration, severity, medical history, age, lifestyle factors (diet, exercise), and current medications.
-2.  Professional tone: Maintain a clear, respectful, and professional tone appropriate for medical consultation.
-3.  Evidence-based practice: Base all responses on current medical evidence and guidelines.
-4.  Transparency: Clearly distinguish between established medical facts, clinical guidance, and areas of uncertainty.
-5.  Structured analysis: Present information in a clear, organized manner following clinical reasoning patterns.
-6.  Citation: Always cite specific sources for medical claims when available using the [source_id] format.
-7.  Limitations: Acknowledge the limits of AI medical advice and recommend in-person consultation when appropriate.
-8.  Comprehensive approach: Consider differential diagnoses and relevant contextual factors.
-9.  Patient-centered: Focus on clinically relevant information while maintaining respect for the patient.
-
-For each consultation:
-1.  Ask clarifying questions if needed (as per guideline 1).
-2.  Provide differential diagnosis with likelihood assessment.
-3.  Suggest appropriate next steps (testing, treatment, referral).
-4.  Include reasoning for your conclusions.
-5.  Cite medical literature or guidelines supporting your assessment using [source_id].
-
-IMPORTANT: Your primary duty is to support clinical decision-making, not replace clinical judgment.
-"""
-
-FOLLOW_UP_PROMPT = """Continue this medical consultation based on the previous discussion.
-Consider the information already gathered and the tentative diagnosis/plan.
-
-When responding to the follow-up:
-1.  Reference relevant details from the prior conversation.
-2.  Address the specific follow-up question with evidence-based information.
-3.  If new information suggests a need for clarification, ask relevant questions.
-4.  Update recommendations if appropriate.
-5.  Maintain the same structured approach with transparent reasoning.
-6.  Cite additional medical literature or guidelines when relevant using [source_id].
-
-Remember that this is an ongoing consultation where continuity of care is important.
-"""
-
-# Function to extract source IDs and replace them with actual links
-def extract_and_link_sources(text, evidence_snippets):
-    """Replace [source_id] placeholders with actual source information"""
-    source_pattern = r'\[([\w\d:_\-\.+]+)\]'  # Expanded to handle more characters including +
-    matches = re.findall(source_pattern, text)
-
-    source_map = {}  # Map to store source_id -> source data
-
-    # First, try direct ID matches (most reliable)
-    for source_id_match in matches:
-        for snippet in evidence_snippets:
-            if source_id_match == snippet["id"]:
-                source_map[source_id_match] = {
-                    "id": snippet["id"],
-                    "title": snippet["title"].strip(),
-                    "url": snippet["url"],
-                    "citation": snippet["citation"]
-                }
-                break
-    
-    # Next, try fuzzy matching for cases where the exact ID isn't matched
-    for source_id_match in matches:
-        if source_id_match not in source_map and source_id_match != "source_id":
-            for snippet in evidence_snippets:
-                # Try to match on partial IDs (e.g. part before a hyphen)
-                snippet_id_parts = snippet["id"].split("-")
-                source_id_parts = source_id_match.split("-")
-                
-                # Check if the first parts match (journal name)
-                if (snippet_id_parts and source_id_parts and 
-                    snippet_id_parts[0] == source_id_parts[0]):
-                    source_map[source_id_match] = {
-                        "id": snippet["id"],
-                        "title": snippet["title"].strip(),
-                        "url": snippet["url"],
-                        "citation": snippet["citation"]
-                    }
-                    break
-    
-    # Handle generic [source_id] placeholder
-    if "source_id" in matches:
-        # Use the first snippet available if we have any
-        if evidence_snippets and "source_id" not in source_map:
-            snippet = evidence_snippets[0]  # Use the first snippet
-            if snippet.get("url") and snippet.get("title"):
-                source_map["source_id"] = {
-                    "id": snippet["id"],
-                    "title": snippet["title"].strip(),
-                    "url": snippet["url"],
-                    "citation": snippet["citation"]
-                }
-
-    # Replace source_id placeholders with actual links in the text
-    linked_text = text
-    for source_id_key, source_data in source_map.items():
-        safe_id = re.escape(source_id_key)
-        pattern = f"\\[{safe_id}\\]"
-        replacement = f"[{source_data['title']}]({source_data['url']})"
-        linked_text = re.sub(pattern, replacement, linked_text)
-    
-    # Handle remaining [source_id] placeholders
-    if "source_id" in source_map and "[source_id]" in linked_text:
-        generic_data = source_map["source_id"]
-        replacement = f"[{generic_data['title']}]({generic_data['url']})"
-        linked_text = re.sub(r'\[source_id\]', replacement, linked_text)
-    
-    # Final fallback for any [source_id] not mapped at all
-    linked_text = re.sub(r'\[source_id\]', "[Medical Reference]", linked_text)
-
-    return linked_text, source_map
-
-# Implement PubMed API integration for medical evidence retrieval
-def fetch_from_pubmed_api(query, max_results=3, api_key=None):
-    """Fetch medical evidence from PubMed API using E-utilities"""
-    results = []
-    
-    # Clean up the query for better results
-    cleaned_query = re.sub(r'^(hi|hello|hey|greetings|good morning|good afternoon|good evening)[,\.]?\s+', '', query.lower())
-    cleaned_query = re.sub(r"(i'?m|i am)\s+a\s+\d+[-\s]year[-\s]old", '', cleaned_query)
-    cleaned_query = re.sub(r'(my name is|i am|i have been|i\'ve been|i was|i have|i\'ve had|i feel|i\'m feeling|i experienced)', '', cleaned_query)
-    
-    # Try to extract key medical symptoms
-    symptom_patterns = [
-        r'(muscle weakness)', r'(fatigue)', r'(rash)', r'(pain)', r'(swelling)',
-        r'(difficulty breathing|shortness of breath)', r'(fever)', r'(headache)',
-        r'(nausea|vomiting)', r'(dizziness)', r'(numbness)', r'(tingling)'
-    ]
-    
-    medical_terms = []
-    for pattern in symptom_patterns:
-        matches = re.findall(pattern, query.lower())
-        if matches:
-            medical_terms.extend(matches)
-    
-    # If we found medical terms, prioritize them in the search
-    if medical_terms:
-        search_query = " AND ".join(medical_terms)
-        # Add the complete cleaned query as a less weighted part
-        if cleaned_query:
-            search_query = f"({search_query}) OR ({cleaned_query})"
-    else:
-        # If no medical terms found, use the cleaned query
-        search_query = cleaned_query
-    
-    # Encode the query for the API
-    encoded_query = urllib.parse.quote(search_query)
-    
-    # Base URL for PubMed E-utilities
-    base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/"
-    
-    # Search parameters
-    search_params = {
-        "db": "pubmed",
-        "term": encoded_query,
-        "retmax": max_results,
-        "retmode": "json",
-        "sort": "relevance"
+import re
+from model import (
+    orchestrator_chat,
+    fetch_medical_evidence,
+    extract_and_link_sources,
+    parse_doctor_response
+)
+
+# Set page config with dark theme
+st.set_page_config(
+    page_title="Medical AI Assistant",
+    page_icon=None,
+    layout="wide",
+    initial_sidebar_state="collapsed"
+)
+
+# Custom CSS for styling with purple->teal gradient and dark mode
+st.markdown("""
+<style>
+    /* Dark mode with purple->teal gradient */
+    body {
+        background-color: #121212;
+        color: #f0f0f0;
+        font-family: 'DM Sans', sans-serif;
+        letter-spacing: -0.02em;
+        line-height: 1.4;
+        margin: 0;
+        padding: 0;
     }
     
-    # Add API key if provided (increases rate limits)
-    if api_key:
-        search_params["api_key"] = api_key
-        
-    try:
-        # First get article IDs
-        search_response = requests.get(f"{base_url}esearch.fcgi", params=search_params)
-        
-        if search_response.status_code != 200:
-            return []
-            
-        search_data = search_response.json()
-        
-        if "esearchresult" in search_data and "idlist" in search_data["esearchresult"]:
-            ids = search_data["esearchresult"]["idlist"]
-            
-            if ids:
-                # Fetch article details
-                fetch_params = {
-                    "db": "pubmed",
-                    "id": ",".join(ids),
-                    "retmode": "xml"
-                }
-                if api_key:
-                    fetch_params["api_key"] = api_key
-                    
-                fetch_response = requests.get(f"{base_url}efetch.fcgi", params=fetch_params)
-                
-                if fetch_response.status_code != 200:
-                    return []
-                    
-                try:
-                    # Parse XML response
-                    root = ET.fromstring(fetch_response.text)
-                    
-                    for article in root.findall(".//PubmedArticle"):
-                        try:
-                            pmid = article.findtext(".//PMID")
-                            title = article.findtext(".//ArticleTitle") or "No title available"
-                            
-                            # Extract abstract
-                            abstract_elements = article.findall(".//AbstractText")
-                            abstract = " ".join([(elem.text or "") for elem in abstract_elements])
-                            
-                            # Extract authors
-                            authors = []
-                            for author in article.findall(".//Author"):
-                                last_name = author.findtext(".//LastName") or ""
-                                initials = author.findtext(".//Initials") or ""
-                                if last_name and initials:
-                                    authors.append(f"{last_name} {initials}")
-                            
-                            author_str = ", ".join(authors[:3])
-                            if len(authors) > 3:
-                                author_str += " et al."
-                                
-                            # Extract journal and date
-                            journal = article.findtext(".//Journal/Title") or "Journal not specified"
-                            year = article.findtext(".//PubDate/Year") or "N/A"
-                            
-                            # Create citation
-                            citation = f"{author_str}. ({year}). {title}. {journal}. PMID: {pmid}"
-                            
-                            # Create direct access URL
-                            url = f"https://pubmed.ncbi.nlm.nih.gov/{pmid}/"
-                            
-                            # Check if free full text is available via PMC
-                            pmc_id = article.findtext(".//ArticleId[@IdType='pmc']")
-                            has_free_text = bool(pmc_id) or article.findtext(".//PublicationStatus") == "epublish"
-                            
-                            # If PMC ID is available, use that URL instead as it provides full text
-                            if pmc_id:
-                                url = f"https://www.ncbi.nlm.nih.gov/pmc/articles/{pmc_id}/"
-                                
-                            results.append({
-                                "id": f"pubmed:{pmid}",
-                                "title": title,
-                                "text": abstract[:800] + "..." if len(abstract) > 800 else abstract,
-                                "citation": citation,
-                                "url": url,
-                                "source_type": "PubMed" + (" (Free Full Text)" if has_free_text else ""),
-                                "is_open_access": has_free_text
-                            })
-                        except Exception:
-                            continue
-                except ET.ParseError:
-                    return []
-                    
-        return results
-    except Exception:
-        return []
-
-def fetch_from_pmc_api(query, max_results=2, api_key=None):
-    """Fetch free full text articles from PubMed Central (PMC)"""
-    results = []
-    
-    # Clean up the query for better results
-    cleaned_query = re.sub(r'^(hi|hello|hey|greetings|good morning|good afternoon|good evening)[,\.]?\s+', '', query.lower())
-    cleaned_query = re.sub(r"(i'?m|i am)\s+a\s+\d+[-\s]year[-\s]old", '', cleaned_query)
-    cleaned_query = re.sub(r'(my name is|i am|i have been|i\'ve been|i was|i have|i\'ve had|i feel|i\'m feeling|i experienced)', '', cleaned_query)
+    /* Main container styling */
+    .main {
+        background: linear-gradient(135deg, rgba(122, 95, 255, 0.05), rgba(0, 209, 178, 0.05));
+        padding: 2rem;
+        max-width: 100%;
+        border-radius: 16px;
+    }
     
-    # Encode for API
-    encoded_query = urllib.parse.quote(cleaned_query + " AND free full text[filter]")
+    /* Header & sidebar styling */
+    .css-1v3fvcr, .css-1vq4p4l {
+        background-color: #121212;
+    }
     
-    # Base URL for E-utilities
-    base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/"
+    /* Chat container */
+    .stChatFloatingInputContainer {
+        border-radius: 16px;
+        box-shadow: 0 4px 20px rgba(0, 0, 0, 0.2);
+        padding: 8px;
+        background-color: #1e1e24;
+    }
     
-    # Search parameters - specifically targeting PMC for open access articles
-    search_params = {
-        "db": "pmc",
-        "term": encoded_query,
-        "retmax": max_results,
-        "retmode": "json",
-        "sort": "relevance"
+    /* Chat input */
+    .stChatInputContainer textarea {
+        border-radius: 12px;
+        padding: 12px;
+        background-color: #2b2b36;
+        border: 1px solid rgba(122, 95, 255, 0.2);
+        color: #f0f0f0;
     }
     
-    # Add API key if provided
-    if api_key:
-        search_params["api_key"] = api_key
-        
-    try:
-        # First get article IDs
-        search_response = requests.get(f"{base_url}esearch.fcgi", params=search_params)
-        
-        if search_response.status_code != 200:
-            return []
-            
-        search_data = search_response.json()
-        
-        if "esearchresult" in search_data and "idlist" in search_data["esearchresult"]:
-            ids = search_data["esearchresult"]["idlist"]
-            
-            if ids:
-                # Fetch article details
-                fetch_params = {
-                    "db": "pmc",
-                    "id": ",".join(ids),
-                    "retmode": "xml"
-                }
-                if api_key:
-                    fetch_params["api_key"] = api_key
-                    
-                fetch_response = requests.get(f"{base_url}efetch.fcgi", params=fetch_params)
-                
-                if fetch_response.status_code != 200:
-                    return []
-                
-                try:
-                    # Parse XML response for PMC articles
-                    root = ET.fromstring(fetch_response.text)
-                    
-                    for article in root.findall(".//article"):
-                        try:
-                            # Get PMC ID
-                            article_id_elements = article.findall(".//article-id")
-                            pmc_id = None
-                            for id_elem in article_id_elements:
-                                if id_elem.get("pub-id-type") == "pmc":
-                                    pmc_id = id_elem.text
-                            
-                            if not pmc_id:
-                                continue
-                            
-                            # Get article title
-                            title_elem = article.find(".//article-title")
-                            title = "".join(title_elem.itertext()) if title_elem is not None else "No title available"
-                            
-                            # Extract abstract
-                            abstract_elem = article.find(".//abstract")
-                            abstract = ""
-                            if abstract_elem is not None:
-                                for p in abstract_elem.findall(".//p"):
-                                    abstract += " ".join(p.itertext()) + " "
-                            
-                            # If no abstract, try to get from first paragraphs
-                            if not abstract:
-                                body = article.find(".//body")
-                                if body is not None:
-                                    paragraphs = body.findall(".//p")
-                                    abstract = " ".join([" ".join(p.itertext()) for p in paragraphs[:3]])
-                            
-                            # Extract journal and date information
-                            journal_elem = article.find(".//journal-title")
-                            journal = "".join(journal_elem.itertext()) if journal_elem is not None else "PMC Journal"
-                            
-                            year_elem = article.find(".//pub-date/year")
-                            year = year_elem.text if year_elem is not None else "N/A"
-                            
-                            # Extract authors
-                            authors = []
-                            for contrib in article.findall(".//contrib[@contrib-type='author']"):
-                                surname = contrib.find(".//surname")
-                                given_names = contrib.find(".//given-names")
-                                if surname is not None and given_names is not None:
-                                    authors.append(f"{surname.text} {given_names.text[0] if given_names.text else ''}")
-                            
-                            author_str = ", ".join(authors[:3])
-                            if len(authors) > 3:
-                                author_str += " et al."
-                            
-                            # Create citation
-                            citation = f"{author_str}. ({year}). {title}. {journal}. PMC{pmc_id}"
-                            
-                            # Create URL for direct access to full text
-                            url = f"https://www.ncbi.nlm.nih.gov/pmc/articles/PMC{pmc_id}/"
-                            
-                            results.append({
-                                "id": f"pmc:{pmc_id}",
-                                "title": title,
-                                "text": abstract[:800] + "..." if len(abstract) > 800 else abstract,
-                                "citation": citation,
-                                "url": url,
-                                "source_type": "PubMed Central (Open Access)",
-                                "is_open_access": True
-                            })
-                        except Exception:
-                            continue
-                except ET.ParseError:
-                    return []
-                    
-        return results
-    except Exception:
-        return []
-
-def fetch_from_who_api(query, max_results=1):
-    """Fetch information from WHO guidelines - using web scraping as alternative to API"""
-    try:
-        # WHO search URL (as they don't have a public API, we use web scraping)
-        search_url = f"https://www.who.int/publications/search-results?indexTerms={query.replace(' ', '+')}"
-        response = requests.get(search_url)
-
-        if response.status_code == 200:
-            soup = BeautifulSoup(response.text, 'html.parser')
-            results = []
-
-            # Extract article information
-            articles = soup.select('.search-results article')[:max_results]
-
-            for article in articles:
-                title_elem = article.select_one('h3')
-                title = title_elem.text.strip() if title_elem else "WHO Guideline"
-
-                desc_elem = article.select_one('.search-description')
-                description = desc_elem.text.strip() if desc_elem else ""
-
-                link_elem = article.select_one('a')
-                link = "https://www.who.int" + link_elem['href'] if link_elem and 'href' in link_elem.attrs else ""
-
-                date_elem = article.select_one('.search-meta')
-                date = date_elem.text.strip() if date_elem else "Date not specified"
-
-                # Generate a unique ID based on the URL
-                who_id = link.split('/')[-1] if link else f"who-{uuid.uuid4().hex[:8]}"
-                
-                results.append({
-                    "id": f"who:{who_id}",
-                    "title": title,
-                    "text": description[:800] + "..." if len(description) > 800 else description,
-                    "citation": f"World Health Organization. ({date}). {title}.",
-                    "url": link,
-                    "source_type": "WHO Guidelines",
-                    "is_open_access": True  # WHO guidelines are freely accessible
-                })
-
-            return results
-        return []
-    except Exception:
-        return []
-
-def fetch_from_core_api(query, max_results=2, api_key=None):
-    """Fetch open access research papers from CORE API"""
-    results = []
+    /* Chat messages */
+    .chat-message {
+        padding: 1.5rem;
+        border-radius: 16px;
+        margin-bottom: 1rem;
+        display: flex;
+        flex-direction: column;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        transition: all 0.2s ease-in-out;
+    }
     
-    # Clean up the query for better results
-    cleaned_query = re.sub(r'^(hi|hello|hey|greetings|good morning|good afternoon|good evening)[,\.]?\s+', '', query.lower())
-    cleaned_query = re.sub(r"(i'?m|i am)\s+a\s+\d+[-\s]year[-\s]old", '', cleaned_query)
-    cleaned_query = re.sub(r'(my name is|i am|i have been|i\'ve been|i was|i have|i\'ve had|i feel|i\'m feeling|i experienced)', '', cleaned_query)
+    .chat-message:hover {
+        box-shadow: 0 6px 16px rgba(0, 0, 0, 0.15);
+    }
     
-    # Extract medical terms for better search
-    symptom_patterns = [
-        r'(muscle weakness)', r'(fatigue)', r'(rash)', r'(pain)', r'(swelling)',
-        r'(difficulty breathing|shortness of breath)', r'(fever)', r'(headache)',
-        r'(nausea|vomiting)', r'(dizziness)', r'(numbness)', r'(tingling)'
-    ]
+    .chat-message.user {
+        background-color: #2b313e;
+        border-left: 3px solid #7A5FFF;
+    }
     
-    medical_terms = []
-    for pattern in symptom_patterns:
-        matches = re.findall(pattern, query.lower())
-        if matches:
-            medical_terms.extend(matches)
+    .chat-message.assistant {
+        background-color: #1e1e2e;
+        border-left: 3px solid #00D1B2;
+    }
     
-    # If we found medical terms, enhance the query
-    if medical_terms:
-        search_query = cleaned_query + " " + " ".join(medical_terms)
-    else:
-        search_query = cleaned_query
+    /* Buttons and toggles */
+    .stButton>button, .stToggle>label {
+        border-radius: 12px;
+        padding: 8px 16px;
+        background: linear-gradient(135deg, #7A5FFF, #00D1B2);
+        color: white;
+        border: none;
+        transition: all 0.2s ease;
+    }
     
-    # Base URL for CORE API
-    base_url = "https://core.ac.uk/api/v3/search/works"
+    .stButton>button:hover, .stToggle>label:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 4px 12px rgba(122, 95, 255, 0.4);
+    }
     
-    # Search parameters with medical focus
-    search_params = {
-        "q": search_query,
-        "limit": max_results * 2,  # Get more results to filter for the best ones
-        "offset": 0,
-        "fields": ["title", "abstract", "authors", "year", "downloadUrl", "sourceFulltextUrl", "doi", "fullText"]
+    /* Expander/Dropdown */
+    .streamlit-expanderHeader {
+        border-radius: 12px;
+        background-color: #2b2b36;
+        border: 1px solid rgba(0, 209, 178, 0.2);
+        color: #f0f0f0;
+        font-weight: 500;
     }
     
-    # Headers with API key
-    headers = {
-        "Authorization": f"Bearer {api_key}" if api_key else None,
-        "Content-Type": "application/json"
+    .streamlit-expanderContent {
+        background-color: #1e1e24;
+        border-radius: 0 0 12px 12px;
+        padding: 12px;
     }
     
-    try:
-        response = requests.post(base_url, json=search_params, headers=headers)
-        
-        if response.status_code != 200:
-            return []
-            
-        data = response.json()
-        
-        if "results" in data:
-            filtered_articles = []
-            
-            # First pass: Collect and score all articles
-            for article in data["results"]:
-                try:
-                    # Score articles for relevance (higher is better)
-                    score = 0
-                    
-                    # Has downloadUrl or sourceFulltextUrl (direct access)
-                    if article.get("downloadUrl") or article.get("sourceFulltextUrl"):
-                        score += 3
-                        
-                    # Has full text in the response
-                    if article.get("fullText"):
-                        score += 2
-                        
-                    # Has abstract
-                    if article.get("abstract") and len(article.get("abstract")) > 100:
-                        score += 1
-                        
-                    # Medical relevance - check title and abstract for medical terms
-                    for term in medical_terms:
-                        if term in (article.get("title", "") + article.get("abstract", "")).lower():
-                            score += 2
-                            
-                    # Store with score for later filtering
-                    filtered_articles.append((score, article))
-                    
-                except Exception:
-                    continue
-            
-            # Sort by score (highest first) and take the top results
-            filtered_articles.sort(reverse=True, key=lambda x: x[0])
-            top_articles = [article for score, article in filtered_articles[:max_results]]
-            
-            # Second pass: Process the top articles in detail
-            for article in top_articles:
-                try:
-                    # Extract article information
-                    title = article.get("title", "No title available")
-                    abstract = article.get("abstract", "")
-                    
-                    # Try to use full text if available, otherwise use abstract
-                    full_text = article.get("fullText", "")
-                    text_content = ""
-                    
-                    if full_text:
-                        # If full text is available, use a summarized version (first part)
-                        text_content = f"[FULL TEXT AVAILABLE] {full_text[:1500]}..."
-                    else:
-                        # Use abstract if no full text
-                        text_content = abstract
-                    
-                    authors = article.get("authors", [])
-                    year = article.get("year", "N/A")
-                    
-                    # Format authors
-                    author_str = ", ".join([f"{author.get('name', '')}" for author in authors[:3]])
-                    if len(authors) > 3:
-                        author_str += " et al."
-                    
-                    # Get the best available URL - prioritize direct download links
-                    url = ""
-                    download_available = False
-                    
-                    if article.get("downloadUrl"):
-                        url = article.get("downloadUrl")
-                        download_available = True
-                    elif article.get("sourceFulltextUrl"):
-                        url = article.get("sourceFulltextUrl")
-                        download_available = True
-                    elif article.get("doi"):
-                        url = f"https://doi.org/{article.get('doi')}"
-                    
-                    # Create citation
-                    citation = f"{author_str}. ({year}). {title}."
-                    if article.get("doi"):
-                        citation += f" DOI: {article['doi']}"
-                    
-                    # Generate a unique ID
-                    core_id = article.get("id", str(uuid.uuid4()))
-                    
-                    # Create source type with clarity about data availability
-                    source_type = "CORE Open Access"
-                    if download_available:
-                        source_type += " (Full Text Available)"
-                    elif full_text:
-                        source_type += " (Full Text Excerpt Included)"
-                    else:
-                        source_type += " (Abstract Only)"
-                    
-                    results.append({
-                        "id": f"core:{core_id}",
-                        "title": title,
-                        "text": text_content[:800] + "..." if len(text_content) > 800 else text_content,
-                        "citation": citation,
-                        "url": url,
-                        "source_type": source_type,
-                        "is_open_access": True  # All CORE articles are open access
-                    })
-                except Exception:
-                    continue
-                    
-        return results
-    except Exception:
-        return []
-
-# Enhanced RAG System with real medical sources
-def fetch_medical_evidence(query, max_results=5):
-    """Fetch medical evidence from multiple sources using real APIs"""
-    results = []
+    /* Hide empty elements and default header */
+    .element-container:has(h1:empty) {
+        display: none;
+    }
+    .block-container {
+        padding-top: 1rem;
+    }
     
-    # Define API keys
-    pubmed_api_key = os.environ.get("PUBMED_API_KEY")
-    core_api_key = os.environ.get("CORE_API_KEY")
+    /* Citations and sources */
+    a {
+        color: #00D1B2;
+        text-decoration: none;
+    }
+    a:hover {
+        text-decoration: underline;
+    }
     
-    # Source 1: PubMed API - prioritize for relevant medical research
-    pubmed_results = fetch_from_pubmed_api(query, max_results=max(2, max_results//2), api_key=pubmed_api_key)
-    if pubmed_results:
-        results.extend(pubmed_results)
+    /* Italicize uncertainties as per UX spec */
+    .uncertainty {
+        font-style: italic;
+        color: rgba(255, 107, 107, 0.8);
+    }
     
-    # Source 2: PubMed Central - free full text articles
-    if len(results) < max_results:
-        remaining = max_results - len(results)
-        pmc_results = fetch_from_pmc_api(query, max_results=remaining, api_key=pubmed_api_key)
-        if pmc_results:
-            results.extend(pmc_results)
+    /* New toggle switch */
+    .toggle-container {
+        display: flex;
+        align-items: center;
+        margin-bottom: 1rem;
+        background-color: #1e1e24;
+        padding: 8px 16px;
+        border-radius: 12px;
+    }
+    .toggle-label {
+        margin-right: 10px;
+        font-weight: 500;
+        color: #f0f0f0;
+    }
     
-    # Source 3: CORE API - open access research papers
-    if len(results) < max_results:
-        remaining = max_results - len(results)
-        core_results = fetch_from_core_api(query, max_results=remaining, api_key=core_api_key)
-        if core_results:
-            results.extend(core_results)
+    /* ChatGPT-like toggle style */
+    .chatgpt-toggle {
+        display: flex;
+        align-items: center;
+        justify-content: flex-end;
+        background-color: rgba(32, 33, 35, 0.5);
+        padding: 4px 12px;
+        border-radius: 8px;
+        margin: 5px 0;
+    }
     
-    # Source 4: WHO Guidelines - if still need more results
-    if len(results) < max_results:
-        remaining = max_results - len(results)
-        who_results = fetch_from_who_api(query, max_results=remaining)
-        if who_results:
-            results.extend(who_results)
+    .chatgpt-toggle .stToggle>label {
+        background: rgba(122, 95, 255, 0.2);
+        padding: 4px 10px;
+        font-size: 0.8rem;
+    }
     
-    # Prioritize sources with full text for better diagnosis
-    results.sort(key=lambda x: (
-        "Full Text" in x.get("source_type", ""), 
-        "CORE" in x.get("source_type", ""),
-        "PMC" in x.get("source_type", ""),
-        "PubMed" in x.get("source_type", "")
-    ), reverse=True)
+    /* Bottom controls tray */
+    .bottom-controls {
+        position: fixed;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        z-index: 100;
+        background-color: #121212;
+        padding-bottom: 10px;
+    }
     
-    return results[:max_results]  # Limit to requested number after sorting
-
-# Function to parse doctor agent responses
-def parse_doctor_response(response_text):
-    """Parse the doctor agent's response into structured components"""
-    # Initialize structure
-    parsed = {
-        "main_response": response_text,
-        "diagnosis": "",
-        "treatment": "",
-        "reasoning": [],
-        "sources": []
+    /* Legal disclaimer (small and muted) */
+    .footer-text {
+        font-size: 0.7rem;
+        color: rgba(240, 240, 240, 0.5);
+        text-align: center;
+        padding: 10px;
+        position: fixed;
+        bottom: 0;
+        width: 100%;
+        z-index: 99;
     }
+</style>
+""", unsafe_allow_html=True)
+
+# Initialize session state
+if 'history' not in st.session_state:
+    st.session_state.history = []
+if 'consultation_id' not in st.session_state:
+    st.session_state.consultation_id = str(uuid.uuid4())[:8]
+if 'use_rag' not in st.session_state:
+    st.session_state.use_rag = True
+
+# Helper function to check if explanation has meaningful content
+def has_meaningful_content(text):
+    if not text:
+        return False
+    
+    # Check if the text is just equal signs or other separators
+    stripped_text = text.strip()
+    if re.match(r'^[=\-_*]+$', stripped_text.replace('\n', '')):
+        return False
+    
+    # Check if the text only contains "## REASONING" with no actual content
+    if "## REASONING" in stripped_text and len(stripped_text) < 20:
+        return False
+        
+    return True
 
-    # Try to extract diagnosis
-    diagnosis_match = re.search(r'(?i)diagnosis:?\s*(.*?)(?:\n\n|\n[A-Z]|\Z)', response_text, re.DOTALL)
-    if diagnosis_match:
-        parsed["diagnosis"] = diagnosis_match.group(1).strip()
-
-    # Try to extract treatment/recommendations
-    treatment_match = re.search(r'(?i)(treatment|recommendations|plan):?\s*(.*?)(?:\n\n|\n[A-Z]|\Z)', response_text, re.DOTALL)
-    if treatment_match:
-        parsed["treatment"] = treatment_match.group(2).strip()
-
-    # Try to extract reasoning if present
-    reasoning_match = re.search(r'(?i)reasoning:?\s*(.*?)(?:\n\n\Z|\Z)', response_text, re.DOTALL)
-    if reasoning_match:
-        reasoning_text = reasoning_match.group(1).strip()
-        # Split into bullet points if present
-        if '\n-' in reasoning_text:
-            parsed["reasoning"] = [item.strip() for item in reasoning_text.split('\n-') if item.strip()]
-            # Clean up first item which might not have a dash
-            if parsed["reasoning"]:
-                parsed["reasoning"][0] = parsed["reasoning"][0].lstrip('- ')
-        else:
-            parsed["reasoning"] = [reasoning_text]
-
-    # Extract sources/references
-    sources_match = re.search(r'(?i)(sources|references):?\s*(.*?)(?:\n\n\Z|\Z)', response_text, re.DOTALL)
-    if sources_match:
-        sources_text = sources_match.group(2).strip()
-        # Split into individual sources
-        if '\n' in sources_text:
-            parsed["sources"] = [item.strip() for item in sources_text.split('\n') if item.strip()]
-        else:
-            parsed["sources"] = [sources_text]
-
-    # Extract citations in the text (format: [source_id])
-    citation_matches = re.findall(r'\[([\w\d:]+)\]', response_text)
-    for citation in citation_matches:
-        if citation not in parsed["sources"]:
-            parsed["sources"].append(citation)
-
-    return parsed
-
-# Enhanced Doctor Agent call with structured output
-def doctor_agent(messages):
-    """Call the LLM to get a structured response using OpenAI API v0.28.1"""
-    try:
-        response = openai.ChatCompletion.create(
-            model="gpt-4o-mini",
-            messages=messages,
-            temperature=0.3
-        )
-        return response.choices[0].message['content']
-    except Exception as e:
-        return f"I'm sorry, there was an error processing your request. Please try again. Error: {str(e)}"
-
-# Single orchestrator turn with enhanced reasoning and citation tracking
-def orchestrator_chat(history, query, use_rag, is_follow_up=False):
-    """Handle a single turn of conversation with the doctor agent"""
-    # Select appropriate system prompt based on whether this is a follow-up
-    if is_follow_up:
-        system = {"role": "system", "content": FOLLOW_UP_PROMPT}
+# Display chat history
+for message in st.session_state.history:
+    if message["role"] == "user":
+        with st.chat_message("user"):
+            st.write(message["content"])
     else:
-        system = {"role": "system", "content": SYSTEM_PROMPT}
-
-    msgs = [system] + history
-
-    # Evidence gathering
-    evidence_snippets = []
-    if use_rag:
-        # Only fetch and format evidence if RAG is enabled
-        evidence_snippets = fetch_medical_evidence(query)
-
-        # Format evidence for the model
-        if evidence_snippets:
-            evidence_text = "MEDICAL EVIDENCE FROM AUTHORITATIVE SOURCES:\n\n"
-
-            for i, snippet in enumerate(evidence_snippets):
-                evidence_text += f"[{snippet['id']}] {snippet['title']}\n"
-                evidence_text += f"Source: {snippet['source_type']}\n"
-                evidence_text += f"Content: {snippet['text']}\n"
-                evidence_text += f"Citation: {snippet['citation']}\n"
-                evidence_text += f"URL: {snippet['url']}\n\n"
-
-            # Enhanced instructions for better source utilization
-            evidence_text += """CITATION INSTRUCTIONS: 
-1. When referencing these sources in your response, use the format [source_id] to cite them.
-2. Prioritize information from sources marked with "Full Text Available" as they provide more comprehensive data.
-3. CORE API sources provide open access full text articles that are particularly valuable for diagnosis.
-4. Use the most relevant medical evidence to support your diagnostic reasoning.
-5. Try to cite multiple sources to provide a well-rounded assessment.
-"""
-
-            msgs.append({"role": "system", "content": evidence_text})
+        with st.chat_message("assistant"):
+            st.markdown(message["content"])
+            # Only display the explanation in an expander if it exists AND has actual content
+            if message.get("explanation") and has_meaningful_content(message.get("explanation")):
+                with st.expander("Show Reasoning"):
+                    st.markdown(message["explanation"])
+                    if message.get("evidence"):
+                        st.markdown("---")
+                        st.markdown("**Legend:** 🔓 = Open Access (full text available)")
+
+# Add spacing at the bottom
+st.markdown("<div style='height: 80px'></div>", unsafe_allow_html=True)
+
+# Chat input
+if prompt := st.chat_input("Describe your symptoms or ask a medical question..."):
+    # Add user message to chat
+    st.session_state.history.append({"role": "user", "content": prompt})
+    with st.chat_message("user"):
+        st.write(prompt)
+    
+    # Show thinking message
+    with st.chat_message("assistant"):
+        thinking_placeholder = st.empty()
+        if st.session_state.use_rag:
+            thinking_placeholder.markdown("🔍 Searching medical databases and analyzing your query...")
         else:
-            # If no evidence was found, inform the model
-            no_evidence_msg = ("Note: No specific medical evidence was found in our databases for this query. "
-                              "Please rely on your general medical knowledge and be sure to recommend "
-                              "appropriate diagnostic steps and medical consultation.")
-            msgs.append({"role": "system", "content": no_evidence_msg})
-
-    # Add instructions for structured output
-    if use_rag:
-        output_instructions = """
-        Please structure your response clearly.
-
-        **Priority 1: Ask Clarifying Questions**
-        If the user's query lacks detail for a proper assessment (e.g., age, specific symptoms, medical history, duration, severity), your HIGHEST priority is to ask these questions first. Do not provide a diagnosis or plan until sufficient information is gathered.
-
-        **Priority 2: Main Response (After Clarification)**
-        Once sufficient information is available (either initially or after asking questions), provide:
-        1.  A direct answer to the patient's concerns.
-        2.  If appropriate, a clear diagnosis or differential diagnosis.
-        3.  Recommendations for a treatment plan or next steps.
-        4.  Ensure you cite medical evidence using the [source_id] format for any claims or information taken from the provided MEDICAL EVIDENCE snippets.
-
-        **After your main response, ALWAYS include these sections:**
-        -   **Reasoning**: Bullet points detailing your clinical reasoning.
-        -   **Sources**: A list of all references cited in your main response, using their full titles and corresponding URLs if they were linked (e.g., [Title of Source](URL)). If a source was just an ID without a direct link in the text, list its ID or citation.
-        """
-    else:
-        # Different instructions when RAG is disabled - no mention of sources or citations
-        output_instructions = """
-        Please structure your response clearly.
-
-        **Priority 1: Ask Clarifying Questions**
-        If the user's query lacks detail for a proper assessment (e.g., age, specific symptoms, medical history, duration, severity), your HIGHEST priority is to ask these questions first. Do not provide a diagnosis or plan until sufficient information is gathered.
-
-        **Priority 2: Main Response (After Clarification)**
-        Once sufficient information is available (either initially or after asking questions), provide:
-        1.  A direct answer to the patient's concerns.
-        2.  If appropriate, a clear diagnosis or differential diagnosis.
-        3.  Recommendations for a treatment plan or next steps.
-
-        **After your main response, ALWAYS include this section:**
-        -   **Reasoning**: Bullet points detailing your clinical reasoning.
-
-        IMPORTANT: Since database search is disabled, do not include citations or sources in your response.
-        """
-
-    msgs.append({"role": "system", "content": output_instructions})
-    msgs.append({"role": "user", "content": query})
-
-    # Get response from doctor agent
-    response = doctor_agent(msgs)
-
-    # Process the response based on whether RAG is enabled
-    if use_rag:
-        # Process the response to replace source placeholders with actual links
-        linked_response, source_map = extract_and_link_sources(response, evidence_snippets)
-        
-        # Parse the response
-        parsed_response = parse_doctor_response(linked_response)
-        
-        # Enhance source information with evidence snippets data
-        enhanced_sources = []
-        # Use the source_map from extract_and_link_sources as the primary guide for cited sources
-        for source_id_key, mapped_data in source_map.items():
-            enhanced_sources.append({
-                "id": mapped_data["id"], # This is the original ID from the snippet
-                "title": mapped_data["title"],
-                "citation": mapped_data["citation"],
-                "url": mapped_data["url"],
-                "source_type": "Referenced Source" # Or derive from snippet if available
-            })
-
-        # Get source types and open access status from original snippets
-        for es in enhanced_sources:
-            for snippet in evidence_snippets:
-                if es["id"] == snippet["id"]:
-                    es["source_type"] = snippet.get("source_type", "Referenced Source")
-                    es["is_open_access"] = snippet.get("is_open_access", False)
-                    break
+            thinking_placeholder.markdown("Analyzing your query...")
         
-        # If there are sources in parsed_response["sources"] that are not in source_map
-        # (e.g., LLM hallucinated an ID or cited something not in snippets), add them.
-        current_enhanced_ids = {es['id'] for es in enhanced_sources}
+        # Get AI response
+        reply, explanation, evidence = orchestrator_chat(
+            st.session_state.history[:-1],  # Exclude the current message
+            prompt,
+            use_rag=st.session_state.use_rag,
+            is_follow_up=len(st.session_state.history) > 1
+        )
         
-        for source_text in parsed_response["sources"]: # source_text could be "[id]", "title (url)", or just "citation"
-            source_id_candidate = source_text.strip("[]") # Basic extraction
-            
-            # Check if this source_id_candidate was part of the original evidence
-            found_in_evidence = False
-            for snippet in evidence_snippets:
-                if source_id_candidate == snippet["id"]:
-                    if source_id_candidate not in current_enhanced_ids:
-                        enhanced_sources.append({
-                            "id": snippet["id"],
-                            "title": snippet["title"],
-                            "citation": snippet["citation"],
-                            "url": snippet["url"],
-                            "source_type": snippet["source_type"],
-                            "is_open_access": snippet.get("is_open_access", False)
-                        })
-                        current_enhanced_ids.add(snippet["id"]) # Add to set to avoid re-adding
-                    found_in_evidence = True
-                    break
-            
-            if not found_in_evidence:
-                # If it's not in source_map and not directly in evidence_snippets by a simple ID match,
-                # it might be a raw citation or a URL. Add it with available info.
-                is_duplicate = False
-                for es_item in enhanced_sources:
-                    if es_item["title"] == source_text or es_item["url"] == source_text or es_item["citation"] == source_text:
-                        is_duplicate = True
-                        break
-                if not is_duplicate and source_text not in current_enhanced_ids:
-                     # Try to extract a URL if present in markdown format
-                    url_match = re.search(r'\[(.*?)\]\((https?://[^)]+)\)', source_text)
-                    if url_match:
-                        title = url_match.group(1)
-                        url = url_match.group(2)
-                    else:
-                        title = source_text # Could be a citation string or a plain title
-                        url = "" # No URL found directly
-
-                    enhanced_sources.append({
-                        "id": source_id_candidate, # Use the candidate, might be a simple title or part of citation
-                        "title": title,
-                        "citation": source_text, # The original text from LLM's source list
-                        "url": url,
-                        "source_type": "Referenced Source (uncategorized)"
-                    })
-                    current_enhanced_ids.add(source_id_candidate)
-
-        # Add the enhanced sources back to the parsed response
-        parsed_response["enhanced_sources"] = enhanced_sources
-        main_response = linked_response
-    else:
-        # If RAG is disabled, just parse the response without source processing
-        parsed_response = parse_doctor_response(response)
-        parsed_response["enhanced_sources"] = []
-        main_response = response
-
-    # Create detailed explanation with reasoning and sources
-    explanation = []
-
-    # Add reasoning section
-    if parsed_response["reasoning"]:
-        explanation.append("## REASONING")
-        for i, reason in enumerate(parsed_response["reasoning"]):
-            explanation.append(f"{i+1}. {reason}")
-        explanation.append("")
-
-    # Only add sources section if RAG is enabled
-    if use_rag and parsed_response["enhanced_sources"]:
-        explanation.append("## SOURCES USED")
-
-        # Add enhanced sources first (these are the ones actually cited in the response)
-        source_added_count = 0
+        # Clear thinking message
+        thinking_placeholder.empty()
         
-        unique_sources_for_display = {} # id: {title, url, citation, source_type}
-        for source in parsed_response["enhanced_sources"]:
-            # Prefer using the mapped title and URL from extract_and_link_sources if available
-            display_id = source.get('id', source.get('title', 'Unknown Source'))
-
-            if display_id not in unique_sources_for_display:
-                 unique_sources_for_display[display_id] = {
-                    "title": source.get('title', 'N/A'),
-                    "url": source.get('url', ''),
-                    "citation": source.get('citation', ''),
-                    "source_type": source.get('source_type', 'Referenced Source'),
-                    "is_open_access": source.get('is_open_access', False)
-                 }
-
-        # Create a categorized display of sources
-        source_categories = {
-            "CORE": [],   # CORE API full text
-            "PMC": [],    # PubMed Central full text
-            "PubMed": [], # PubMed abstracts
-            "WHO": [],    # WHO guidelines
-            "Other": []   # Uncategorized
-        }
+        # Display response
+        st.markdown(reply)
         
-        # Categorize sources
-        for key, src_data in unique_sources_for_display.items():
-            source_type = src_data['source_type']
-            
-            if "CORE" in source_type:
-                source_categories["CORE"].append((key, src_data))
-            elif "PMC" in source_type:
-                source_categories["PMC"].append((key, src_data))
-            elif "PubMed" in source_type:
-                source_categories["PubMed"].append((key, src_data))
-            elif "WHO" in source_type:
-                source_categories["WHO"].append((key, src_data))
-            else:
-                source_categories["Other"].append((key, src_data))
-        
-        # Display sources by category
-        for category, sources in source_categories.items():
-            if sources:
-                if category != "Other":  # Skip category header for Other
-                    explanation.append(f"### {category} Sources:")
+        # Add explanation in an expander ONLY if explanation has meaningful content
+        if explanation and has_meaningful_content(explanation):
+            with st.expander("Show Reasoning"):
+                st.markdown(explanation)
                 
-                for key, src_data in sources:
-                    title = src_data['title']
-                    url = src_data['url']
-                    is_open_access = src_data.get('is_open_access', False)
-                    
-                    if url: # If URL exists, make it a markdown link
-                        explanation.append(f"- [{title}]({url}) {' 🔓' if is_open_access else ''}")
-                    else: # Otherwise, just list the title or ID
-                        explanation.append(f"- {title}")
-
-                    if src_data['source_type']:
-                        explanation.append(f"  Source Type: {src_data['source_type']}")
-                    if src_data['citation']: # Always show citation if available
-                        explanation.append(f"  Citation: {src_data['citation']}")
-                    explanation.append("") # Add a blank line for spacing
-                    source_added_count += 1
-
-        if source_added_count == 0 and parsed_response["sources"]: # Fallback to raw sources if enhanced list is empty but LLM listed some
-            explanation.append("## SOURCES MENTIONED (Raw)") # Indicate these are less processed
-            for source_text in parsed_response["sources"]:
-                explanation.append(f"- {source_text.strip()}")
-            explanation.append("")
-            source_added_count +=1
-
-        # If we still have no sources, remove the header
-        if source_added_count == 0: # Check if any sources were actually added to explanation
-            # Remove "## SOURCES USED" header if it was added but no sources followed
-            if explanation and explanation[-1] == "## SOURCES USED":
-                explanation.pop()
-
-        # Enhanced version to display clickable article links
-        # Check if we have evidence snippets but no sources in the explanation
-        if evidence_snippets and "## SOURCES USED" not in "\n".join(explanation):
-            # If AI didn't explicitly cite sources, show available evidence anyway
-            additional_explanation = ["\n## AVAILABLE MEDICAL SOURCES"]
-            
-            # Create categorized display of all available sources
-            categorized_snippets = {
-                "CORE Open Access": [],   # CORE API full text
-                "PubMed Central": [],     # PMC full text
-                "PubMed": [],             # PubMed abstracts
-                "WHO Guidelines": [],     # WHO guidelines
-                "Other": []               # Uncategorized
-            }
-            
-            # Categorize snippets
-            for snippet in evidence_snippets:
-                source_type = snippet.get("source_type", "")
-                
-                if "CORE" in source_type:
-                    categorized_snippets["CORE Open Access"].append(snippet)
-                elif "PMC" in source_type:
-                    categorized_snippets["PubMed Central"].append(snippet)
-                elif "PubMed" in source_type and "PMC" not in source_type:
-                    categorized_snippets["PubMed"].append(snippet)
-                elif "WHO" in source_type:
-                    categorized_snippets["WHO Guidelines"].append(snippet)
-                else:
-                    categorized_snippets["Other"].append(snippet)
-            
-            # Display snippets by category
-            for category, snippets in categorized_snippets.items():
-                if snippets:
-                    if category != "Other":  # Skip category header for Other
-                        additional_explanation.append(f"### {category}:")
-                    
-                    for snippet in snippets:
-                        title = snippet.get("title", "Unknown Title")
-                        url = snippet.get("url", "")
-                        source_type = snippet.get("source_type", "Medical Source")
-                        is_open_access = snippet.get("is_open_access", False)
-                        
-                        if url:
-                            # Format as clickable markdown link with open access indicator
-                            additional_explanation.append(f"- [{title}]({url}) {' 🔓' if is_open_access else ''}")
-                        else:
-                            additional_explanation.append(f"- {title} {' 🔓' if is_open_access else ''}")
-                            
-                        if "source_type" in snippet:
-                            additional_explanation.append(f"  Source Type: {snippet['source_type']}")
-                        if "citation" in snippet:
-                            additional_explanation.append(f"  Citation: {snippet['citation']}")
-                        additional_explanation.append("")
-                
-            # Add to the main explanation
-            explanation.extend(additional_explanation)
-
-        # Add a note about data availability
-        data_availability_note = [
-            "\n## DATA AVAILABILITY NOTE",
-            "- PubMed sources typically provide abstracts only, unless marked as free full text",
-            "- PubMed Central (PMC) sources provide complete free full text articles",
-            "- CORE Open Access sources provide full text content from research repositories",
-            "- WHO Guidelines provide official medical recommendations and protocols",
-            "- Sources marked with 🔓 indicate open access content with full text available"
-        ]
-        explanation.extend(data_availability_note)
-
-    # Format explanation as string
-    explanation_text = "\n".join(explanation)
-
-    # Update conversation history
-    history.append({"role": "user", "content": query})
-    history.append({"role": "assistant", "content": main_response})
-
-    return main_response, explanation_text, evidence_snippets
-
-# Enhanced interactive loop with better handling of consultations
-def run_consultation(use_rag=True):
-    """Run an interactive medical consultation"""
-    history = []
-    print("\n===== MEDICAL AI ASSISTANT =====")
-    print("Type 'exit' to end or 'next' for a new case.\n")
-    
-    if use_rag:
-        print("Using medical evidence from: PubMed, PMC, CORE, and WHO")
-        print("Sources marked with 🔓 provide full text access\n")
-
-    consultation_id = str(uuid.uuid4())[:8]
-    print(f"Consultation ID: {consultation_id}")
-
-    query = input("\nYou: ")
-    while query.lower() != "exit":
-        # Track if this is a follow-up question
-        is_follow_up = len(history) > 0
-
-        # Inform user that evidence is being fetched if RAG is enabled
-        if use_rag:
-            print("\nSearching medical databases...")
-            
-        # Process query
-        reply, explanation, evidence = orchestrator_chat(history, query, use_rag, is_follow_up)
-
-        # Display the AI response
-        print("\n" + "=" * 30)
-        print("AI RESPONSE")
-        print("=" * 30)
-        print(reply)
-
-        # Always show explanation/reasoning
-        print("\n" + "=" * 30)
-        print("DETAILED EXPLANATION")
-        print("=" * 30)
-        # Ensure explanation is not empty before printing, or print a default message
-        if explanation and explanation.strip() and explanation.strip() != "="*50:
-            print(explanation)
-        else:
-            print("No detailed explanation or sources were generated for this response.")
-
-        # Add Open Access Legend if evidence sources were found
-        if evidence:
-            print("\nLEGEND: 🔓 = Open Access (full text available)")
-            
-        # Check if we need to continue with follow-up or start a new case
-        next_action = input("\nFollow-up? (or 'next' for new case, 'exit' to end): ")
-
-        if next_action.lower() == "exit":
-            break
-        elif next_action.lower() == "next":
-            # Start a new consultation
-            history = []
-            consultation_id = str(uuid.uuid4())[:8]
-            print(f"\nNew Consultation ID: {consultation_id}")
-            query = input("\nYou: ")
-        else:
-            # Continue with follow-up
-            query = next_action
-
-    print("\nConsultation ended.")
-
-# Save consultation to file
-def save_consultation(history, consultation_id):
-    """Save the consultation history to a file"""
-    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    filename = f"consultation_{consultation_id}_{timestamp}.json"
-
-    with open(filename, 'w') as f:
-        json.dump(history, f, indent=2)
-
-    print(f"Consultation saved to {filename}")
-
-# Main entry point
-if __name__ == "__main__":
-    print("\nInitializing Medical AI Assistant...")
-    run_consultation(use_rag=True)
+                # Add legend if evidence was found
+                if evidence:
+                    st.markdown("---")
+                    st.markdown("**Legend:** 🔓 = Open Access (full text available)")
+    
+    # Add assistant response to history with all necessary fields
+    st.session_state.history.append({
+        "role": "assistant", 
+        "content": reply,
+        "explanation": explanation,
+        "evidence": evidence if evidence else []
+    })
+
+# Fixed bottom toggle position - after the chat input
+with st.container():
+    # Create bottom controls tray
+    st.markdown("<div class='bottom-controls'>", unsafe_allow_html=True)
+    
+    # Add toggle inside the bottom tray
+    cols = st.columns([3, 1])
+    with cols[1]:
+        st.markdown("<div class='chatgpt-toggle'>", unsafe_allow_html=True)
+        st.session_state.use_rag = st.toggle("Database Search", value=st.session_state.use_rag, 
+                                             help="Toggle to enable or disable medical database search")
+        st.markdown("</div>", unsafe_allow_html=True)
+    st.markdown("</div>", unsafe_allow_html=True)
+
+# Small, unobtrusive legal disclaimer 
+st.markdown("""
+<div class="footer-text">
+    For informational purposes only. Not a substitute for professional medical advice.
+</div>
+""", unsafe_allow_html=True)