Update app.py

app.py

@@ -1,207 +1,274 @@
 import streamlit as st
 import google.generativeai as genai
 import os
-# from PIL import Image # Removing image focus for this agentic text example
-import io
+from PIL import Image
+import io # Needed for handling image bytes
 from typing import Optional, Tuple, Any # For type hinting
 
 # --- Configuration and Initialization ---
 
-# Securely load API key (Prioritize Secrets, then Env Vars)
+# Securely load API key
+# Prioritize Streamlit secrets, fall back to environment variable for flexibility
 GEMINI_API_KEY = st.secrets.get("GEMINI_API_KEY", os.environ.get("GEMINI_API_KEY"))
 
-# Configure Gemini Client
+# Configure Gemini Client (only if key is found)
 genai_client_configured = False
 if GEMINI_API_KEY:
     try:
         genai.configure(api_key=GEMINI_API_KEY)
         genai_client_configured = True
     except Exception as e:
-        st.error(f"Fatal Error: Failed to configure Google Generative AI. Check API Key and permissions. Details: {e}")
-        st.stop()
+        st.error(f"Failed to configure Google Generative AI: {e}")
+        st.stop() # Stop execution if configuration fails
 else:
     st.error("⚠️ Gemini API Key not found. Please configure `GEMINI_API_KEY` in Streamlit secrets or environment variables.")
-    st.stop()
+    st.stop() # Stop execution if no API key
 
-# Initialize models (Using specific models for consistency)
-# Using a potentially more powerful model like 1.5 Pro might be beneficial for complex reasoning
-MODEL_NAME = 'gemini-1.5-pro-latest' # Or 'gemini-1.5-flash' if speed is critical
+# Initialize models (only if client configured)
+# Using specific model versions can be good practice for reproducibility
+TEXT_MODEL_NAME = 'gemini-1.5-flash' # Or 'gemini-pro' if preferred
+VISION_MODEL_NAME = 'gemini-1.5-flash' # Or 'gemini-pro-vision' if preferred
 
 if genai_client_configured:
     try:
-        model = genai.GenerativeModel(MODEL_NAME)
-        # vision_model = genai.GenerativeModel('gemini-pro-vision') # Keep commented unless adding image capability back
+        model = genai.GenerativeModel(TEXT_MODEL_NAME)
+        vision_model = genai.GenerativeModel(VISION_MODEL_NAME)
     except Exception as e:
-        st.error(f"Fatal Error: Failed to initialize Gemini model ({MODEL_NAME}). Details: {e}")
+        st.error(f"Failed to initialize Gemini models ({TEXT_MODEL_NAME}, {VISION_MODEL_NAME}): {e}")
         st.stop()
 else:
-    st.error("AI Model could not be initialized due to configuration issues.")
+    # This state should technically not be reached due to earlier st.stop() calls,
+    # but it's good defensive programming.
+    st.error("AI Models could not be initialized due to configuration issues.")
     st.stop()
 
 
-# --- Core Agentic AI Simulation Function ---
-
-# This prompt instructs the LLM to simulate a structured, agent-like reasoning process
-# focused on differential diagnosis support.
-AGENTIC_ANALYSIS_PROMPT_TEMPLATE = """
-**Simulated Clinical Reasoning Agent Task:**
-
-**Role:** You are an AI assistant simulating an agentic clinical reasoning process to support a healthcare professional. Your goal is NOT to diagnose, but to structure information, generate possibilities, and suggest logical next steps based *strictly* on the provided information.
-
-**Input Data:** You will receive unstructured clinical information (e.g., symptoms, history, basic findings). Assume this is the *only* information available unless stated otherwise.
+# --- Core AI Interaction Functions ---
 
-**Simulated Agentic Steps (Perform these sequentially in your response):**
+# Define more sophisticated prompts emphasizing analysis and *potential* findings
+# CRITICAL: Avoid definitive "diagnosis" language. Focus on assisting clinical judgment.
+TEXT_ANALYSIS_PROMPT_TEMPLATE = """
+**Medical Information Analysis Request:**
 
-1.  **Information Extraction & Structuring:**
-    *   Identify and list the key patient demographics (age, sex, if provided).
-    *   List the primary symptoms and signs presented.
-    *   Summarize relevant medical history points.
-    *   Note any explicitly mentioned negative findings (pertinent negatives).
+**Context:** Analyze the provided medical text (symptoms, history, or reports).
+**Task:**
+1.  **Identify Key Findings:** Extract significant symptoms, signs, or data points.
+2.  **Potential Considerations:** Based *only* on the provided text, list potential underlying conditions or areas of concern that *might* warrant further investigation by a qualified healthcare professional. Use cautious language (e.g., "suggests potential for," "could be consistent with," "warrants investigation into").
+3.  **Risk Factors (if applicable):** Mention any potential risk factors identifiable from the text.
+4.  **Information Gaps:** Highlight any missing information that would be crucial for a clinical assessment.
+5.  **Disclaimer:** Explicitly state that this analysis is AI-generated, not a diagnosis, and cannot replace professional medical evaluation.
 
-2.  **Differential Considerations Generation:**
-    *   Based *only* on the structured information from Step 1, generate a list of **potential differential considerations** (possible conditions that *could* explain the findings).
-    *   **Use cautious and probabilistic language:** "could be consistent with," "warrants consideration," "less likely but possible," "should be ruled out." **AVOID definitive statements.**
-    *   Briefly state the primary rationale linking each consideration to the key findings.
+**Input Text:**
+---
+{text_input}
+---
 
-3.  **Information Gap Analysis:**
-    *   Identify critical pieces of information typically needed for assessment that are missing from the input (e.g., specific lab results, imaging details, physical exam specifics, duration/onset details).
+**Analysis:**
+"""
 
-4.  **Suggested Next Steps for Investigation (for the Clinician):**
-    *   Propose logical next steps a **healthcare professional might consider** to narrow down the possibilities or gather missing information.
-    *   Categorize suggestions (e.g., Further History Taking, Physical Examination Points, Laboratory Tests, Imaging Studies).
-    *   Frame these as *suggestions* for the clinician's judgment (e.g., "Consider ordering...", "Assessment of X may be informative", "Further questioning about Y could clarify...").
+IMAGE_ANALYSIS_PROMPT_TEMPLATE = """
+**Medical Image Analysis Request:**
 
-5.  **Mandatory Disclaimer:** Conclude with: "This AI-generated analysis is for informational support only. It is **NOT** a diagnosis and cannot replace the judgment of a qualified healthcare professional who must consider the full clinical context, conduct necessary examinations, and interpret investigations."
+**Context:** Analyze the provided medical image. User may provide additional context or questions.
+**Task:**
+1.  **Describe Visible Structures:** Briefly describe the main anatomical structures visible.
+2.  **Identify Potential Anomalies:** Point out any visible areas that *appear* abnormal or deviate from typical presentation (e.g., "potential opacity in the lower left lung field," "area of altered signal intensity," "possible asymmetry"). Use cautious, descriptive language.
+3.  **Correlate with User Prompt (if provided):** If the user asked a specific question, address it based *only* on the visual information.
+4.  **Limitations:** State that image quality, view, and lack of clinical context limit the analysis.
+5.  **Disclaimer:** Explicitly state this is an AI-based visual analysis, not a radiological interpretation or diagnosis, and requires review by a qualified radiologist or physician alongside clinical information.
 
-**Input Clinical Information:**
+**User's Additional Context/Question (if any):**
 ---
-{text_input}
+{user_prompt}
 ---
 
-**Agentic Analysis:**
+**Image Analysis:**
 """
 
-def run_agentic_reasoning(text_input: str) -> Tuple[Optional[str], Optional[str]]:
+def analyze_medical_text(text_input: str) -> Tuple[Optional[str], Optional[str]]:
     """
-    Simulates an agentic reasoning process on clinical text using the Gemini model.
+    Sends medical text to the Gemini model for analysis using a structured prompt.
 
     Args:
-        text_input: The clinical information provided by the user.
+        text_input: The medical text provided by the user.
 
     Returns:
         A tuple containing:
-        - The structured analysis text (str) if successful, None otherwise.
+        - The analysis text (str) if successful, None otherwise.
         - An error message (str) if an error occurred, None otherwise.
     """
-    if not text_input or not text_input.strip():
+    if not text_input:
         return None, "Input text cannot be empty."
     try:
-        prompt = AGENTIC_ANALYSIS_PROMPT_TEMPLATE.format(text_input=text_input)
-        # Consider adding safety settings if dealing with potentially sensitive outputs
-        # safety_settings = [...]
-        # response = model.generate_content(prompt, safety_settings=safety_settings)
+        prompt = TEXT_ANALYSIS_PROMPT_TEMPLATE.format(text_input=text_input)
         response = model.generate_content(prompt)
+        # Add safety check for response structure if needed (e.g., check for blocked content)
+        if response.parts:
+            return response.text, None
+        elif response.prompt_feedback.block_reason:
+             return None, f"Analysis blocked due to: {response.prompt_feedback.block_reason.name}. Please revise input."
+        else:
+             return None, "Received an empty or unexpected response from the AI."
+
+    except Exception as e:
+        st.error(f"An error occurred during text analysis: {e}") # Log for debugging
+        return None, f"Error communicating with the AI model. Details: {e}"
+
+def analyze_medical_image(image_file: Any, user_prompt: str = "") -> Tuple[Optional[str], Optional[str]]:
+    """
+    Sends a medical image (and optional prompt) to the Gemini Vision model for analysis.
+
+    Args:
+        image_file: The uploaded image file object from Streamlit.
+        user_prompt: Optional text context or specific questions from the user.
+
+    Returns:
+        A tuple containing:
+        - The analysis text (str) if successful, None otherwise.
+        - An error message (str) if an error occurred, None otherwise.
+    """
+    if not image_file:
+        return None, "Image file cannot be empty."
+    try:
+        # Ensure image is opened correctly, handle potential errors
+        try:
+            image = Image.open(image_file)
+            # Optional: Convert image to a supported format if needed, e.g., RGB
+            if image.mode != 'RGB':
+                 image = image.convert('RGB')
+        except Exception as img_e:
+             return None, f"Error opening or processing image file: {img_e}"
+
+        prompt_text = IMAGE_ANALYSIS_PROMPT_TEMPLATE.format(user_prompt=user_prompt if user_prompt else "N/A")
+
+        # Prepare content for the vision model
+        model_input = [prompt_text, image]
+
+        response = vision_model.generate_content(model_input)
 
-        # Check for blocked content or other issues
+        # Add safety check for response structure
         if response.parts:
             return response.text, None
         elif response.prompt_feedback.block_reason:
-             return None, f"Analysis blocked by safety filters: {response.prompt_feedback.block_reason.name}. Please review input for potentially harmful content or adjust safety settings if appropriate."
+            return None, f"Analysis blocked due to: {response.prompt_feedback.block_reason.name}. This might be due to sensitive content policies."
         else:
-             # Handle cases where the response might be empty but not explicitly blocked
-             candidate = response.candidates[0] if response.candidates else None
-             if candidate and candidate.finish_reason != "STOP":
-                 return None, f"Analysis stopped prematurely. Reason: {candidate.finish_reason.name}. The input might be too complex or ambiguous."
-             else:
-                 return None, "Received an empty or unexpected response from the AI model. The model may not have been able to process the request."
+            return None, "Received an empty or unexpected response from the AI."
 
     except Exception as e:
-        st.error(f"Critical Error during AI Analysis: {e}", icon="🚨") # Log for debugging
-        # Provide a user-friendly error message
-        return None, f"An error occurred while communicating with the AI model. Please try again later or check the input. Details: {e}"
+        st.error(f"An error occurred during image analysis: {e}") # Log for debugging
+        return None, f"Error communicating with the AI model. Details: {e}"
 
 
 # --- Streamlit User Interface ---
 
 def main():
-    st.set_page_config(
-        page_title="Agentic AI Clinical Reasoning Support",
-        layout="wide",
-        initial_sidebar_state="expanded"
-        )
+    st.set_page_config(page_title="AI Medical Information Assistant", layout="wide")
 
-    # --- Header ---
-    st.title("🤖 Agentic AI: Clinical Reasoning Support Tool")
-    st.caption(f"Powered by Google Gemini ({MODEL_NAME})")
-    st.markdown("---")
+    st.title("🤖 AI Medical Information Assistant")
+    st.caption(f"Powered by Google Gemini ({TEXT_MODEL_NAME} / {VISION_MODEL_NAME})")
 
     # --- CRITICAL DISCLAIMER ---
     st.warning(
         """
-        **🔴 EXTREMELY IMPORTANT DISCLAIMER 🔴**
-        *   This tool **SIMULATES** an AI reasoning process. It **DOES NOT DIAGNOSE** diseases or provide medical advice.
-        *   Outputs are based **SOLELY** on the text input and the AI's internal knowledge, which may be incomplete or contain inaccuracies. **It lacks real-world clinical context.**
-        *   **NEVER** use this tool for actual patient diagnosis, treatment decisions, or clinical management. It is intended for **educational and conceptual purposes ONLY**, potentially aiding clinicians in organizing thoughts or exploring possibilities.
-        *   **ALWAYS rely on the expertise and judgment of qualified healthcare professionals.**
-        *   **PRIVACY ALERT:** Do **NOT** enter identifiable patient information (PHI) unless you comply with all legal and ethical requirements (e.g., HIPAA, GDPR, patient consent). You are responsible for the data you input.
-        """,
-        icon="⚠️"
+        **IMPORTANT DISCLAIMER:**
+        *   This tool uses AI to analyze information but **DOES NOT PROVIDE MEDICAL ADVICE OR DIAGNOSIS.**
+        *   The analysis is based solely on the input provided and may be incomplete, inaccurate, or lack clinical context.
+        *   **ALWAYS consult a qualified healthcare professional** for any health concerns, diagnosis, or treatment decisions.
+        *   Do not rely on this tool for medical decisions. It is for informational and educational purposes only, potentially assisting clinicians by highlighting areas for review.
+        *   **Do not upload identifiable patient information** unless you have explicit consent and comply with all privacy regulations (e.g., HIPAA).
+        """
     )
-    st.markdown("---")
-
-    # --- Input Area ---
-    st.header("Clinical Information Input")
-    st.markdown("Enter de-identified clinical information below (e.g., symptoms, brief history, key findings). The AI will attempt a structured analysis.")
 
-    text_input = st.text_area(
-        "Enter Clinical Data:",
-        height=300,
-        placeholder="Example: A 68-year-old male presents with sudden onset shortness of breath and pleuritic chest pain. History of recent long-haul flight. Vitals show tachycardia (HR 110) and mild hypoxia (SpO2 92% on room air). No significant cardiac history mentioned...",
-        key="clinical_text_input"
+    st.sidebar.header("Input Options")
+    input_method = st.sidebar.radio(
+        "Select Input Type:",
+        ("Text Description", "Medical Image"),
+        help="Choose whether to analyze text-based medical information or a medical image."
     )
 
-    # --- Action Button ---
-    analyze_button = st.button("▶️ Run Agentic Analysis", key="analyze_button", type="primary", help="Click to start the simulated reasoning process.")
-
-    st.markdown("---") # Separator before results
-
-    # --- Output Area ---
-    st.header("Analysis Results")
-
-    if analyze_button:
-        if text_input:
-            with st.spinner("🧠 Simulating agentic reasoning... Please wait."):
-                analysis_result, error_message = run_agentic_reasoning(text_input)
-
-            if error_message:
-                 st.error(f"Analysis Failed: {error_message}", icon="❌")
-            elif analysis_result:
-                 st.markdown("**Simulated Agent Analysis Output:**")
-                 st.markdown(analysis_result) # Use markdown for better formatting
-            else:
-                 st.error("An unexpected issue occurred. No analysis was returned.", icon="❓")
-        else:
-            st.warning("Please enter clinical information in the text area above before analyzing.", icon="☝️")
-    else:
-        st.info("Analysis results will appear here after you enter information and click 'Run Agentic Analysis'.")
-
-    # --- Sidebar for Explanation/Prompt ---
-    st.sidebar.header("About This Tool")
-    st.sidebar.info(
-        "This application demonstrates how an AI model (Gemini) can be prompted to simulate "
-        "a structured, agent-like approach to analyzing clinical information. It focuses on "
-        "differential considerations and suggesting investigation pathways for **clinician review**."
-    )
-    with st.sidebar.expander("View the Agentic Prompt Structure"):
-        st.markdown(f"```plaintext\n{AGENTIC_ANALYSIS_PROMPT_TEMPLATE.split('---')[0]} ... [Input Text] ...\n```")
-        st.caption("The prompt guides the AI to break down the task into logical steps.")
-
-    st.sidebar.header("Ethical Considerations")
-    st.sidebar.error(
-        "**Crucial Reminder:** This AI is a tool, not a clinician. It has limitations and biases. "
-        "Clinical decisions require human expertise, empathy, and comprehensive patient assessment. "
-        "Misuse can lead to harm."
-    )
+    st.sidebar.markdown("---") # Visual separator
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.header("Input")
+        if input_method == "Text Description":
+            st.subheader("Enter Medical Text")
+            text_input = st.text_area(
+                "Paste symptoms, patient history excerpt, or non-identifiable report sections:",
+                height=300,
+                placeholder="Example: 55-year-old male presents with intermittent chest pain, worse on exertion. History of hypertension. Non-smoker...",
+                key="text_input_area" # Add key for potential state management
+            )
+            analyze_button = st.button("Analyze Text", key="analyze_text_button", type="primary")
+
+            if analyze_button and text_input:
+                with st.spinner("🧠 Analyzing Text... Please wait."):
+                    analysis_result, error_message = analyze_medical_text(text_input)
+
+                if error_message:
+                     with col2:
+                        st.error(f"Analysis Failed: {error_message}")
+                elif analysis_result:
+                     with col2:
+                        st.header("Analysis Results")
+                        st.markdown(analysis_result) # Use markdown for better formatting
+                else:
+                    # Handle unexpected case where both are None
+                     with col2:
+                         st.error("An unknown error occurred during analysis.")
+
+            elif analyze_button and not text_input:
+                 st.warning("Please enter some text to analyze.")
+
+
+        elif input_method == "Medical Image":
+            st.subheader("Upload Medical Image")
+            image_file = st.file_uploader(
+                "Upload an image (e.g., X-ray, CT slice, pathology slide). Supported: PNG, JPG, JPEG.",
+                type=["png", "jpg", "jpeg"],
+                key="image_uploader"
+            )
+            user_image_prompt = st.text_input(
+                "Optional: Add context or specific questions for the image analysis:",
+                placeholder="Example: 'Check for abnormalities in the left lung apex' or 'Patient context: Follow-up scan after treatment'",
+                key="image_prompt_input"
+            )
+            analyze_button = st.button("Analyze Image", key="analyze_image_button", type="primary")
+
+            if analyze_button and image_file:
+                 # Display uploaded image immediately for confirmation
+                 st.image(image_file, caption="Uploaded Image Preview", use_column_width=True)
+                 with st.spinner("🖼️ Analyzing Image... Please wait."):
+                     analysis_result, error_message = analyze_medical_image(image_file, user_image_prompt)
+
+                 if error_message:
+                     with col2:
+                        st.error(f"Analysis Failed: {error_message}")
+                 elif analysis_result:
+                     with col2:
+                        st.header("Image Analysis Results")
+                        st.markdown(analysis_result)
+                 else:
+                      with col2:
+                        st.error("An unknown error occurred during analysis.")
+
+            elif analyze_button and not image_file:
+                 st.warning("Please upload an image file to analyze.")
+
+
+    # Display placeholder in result column if nothing submitted yet
+    # Check if 'analysis_result' or 'error_message' exists in session state if needed for persistence,
+    # but for this simpler flow, checking button presses is often sufficient.
+    # A simple way is to check if the button was pressed in the current run.
+    button_pressed = st.session_state.get('analyze_text_button', False) or st.session_state.get('analyze_image_button', False)
+    if not button_pressed:
+         with col2:
+             st.info("Analysis results will appear here once input is submitted.")
+
+
+    st.sidebar.markdown("---")
+    st.sidebar.info("Remember: This AI tool is an assistant, not a substitute for professional medical expertise.")
 
 if __name__ == "__main__":
     main()