Update app.py

app.py

@@ -1,25 +1,36 @@
 import os
 import gradio as gr
 import pandas as pd
-from groq import Groq
 from PIL import Image
 import io
 import datetime
 import re
-from google import genai
-from google.genai import types
-import traceback # For detailed error logging
+import traceback
+import base64
+from openai import OpenAI
 
-# Initialize Groq client (for chat/assessment)
-# Ensure GROQ_API_KEY is set in your environment variables
+# Initialize OpenAI client
 try:
-    groq_client = Groq(api_key=os.environ.get("GROQ_API_KEY"))
+    openai_client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
 except Exception as e:
-    print(f"Error initializing Groq client: {e}")
-    groq_client = None # Set to None to handle initialization errors gracefully
+    print(f"Error initializing OpenAI client: {e}")
+    openai_client = None
 
-# NOTE: Gemini client initialization will happen inside the analyze_ecg_image function
-# Ensure GEMINI_API_KEY is set in your environment variables
+# Function to encode the image
+def encode_image(image):
+    if isinstance(image, Image.Image):
+        # Convert PIL Image to bytes
+        buffered = io.BytesIO()
+        # Ensure image is in RGB format
+        if image.mode in ('RGBA', 'P', 'LA'):
+            image = image.convert('RGB')
+        image.save(buffered, format="JPEG")
+        image_bytes = buffered.getvalue()
+        return base64.b64encode(image_bytes).decode("utf-8")
+    elif isinstance(image, str) and os.path.exists(image):
+        with open(image, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode("utf-8")
+    return None
 
 # Process patient history file
 def process_patient_history(file):
@@ -28,7 +39,7 @@ def process_patient_history(file):
 
     try:
         # Check file extension
-        file_path = file.name # Gradio File object usually has a .name attribute with the path
+        file_path = file.name
         file_ext = os.path.splitext(file_path)[1].lower()
 
         if file_ext == '.txt':
@@ -42,7 +53,6 @@ def process_patient_history(file):
             if file_ext == '.csv':
                 df = pd.read_csv(file_path)
             else:
-                # Specify engine for newer xlsx files if needed
                 try:
                     df = pd.read_excel(file_path)
                 except ImportError:
@@ -50,15 +60,11 @@ def process_patient_history(file):
                 except Exception as e_excel:
                      return f"Error reading Excel file: {e_excel}"
 
-
             # Convert dataframe to formatted string
             formatted_data = "PATIENT INFORMATION:\n\n"
             if not df.empty:
-                 # Assuming the first row contains the relevant patient data
                 for column in df.columns:
-                    # Handle potential missing values gracefully
                     value = df.iloc[0].get(column, 'N/A')
-                    # Convert value to string to avoid potential type issues
                     formatted_data += f"{column}: {str(value)}\n"
             else:
                 formatted_data += "Spreadsheet is empty or format is not recognized correctly."
@@ -76,177 +82,126 @@ def process_patient_history(file):
         print(f"Error processing patient history file:\n{traceback.format_exc()}")
         return f"Error processing patient history file: {str(e)}"
 
-
-# Extract ECG readings from image using Gemini Vision model
-def analyze_ecg_image(image, vision_model="gemini-2.0-flash-exp"):
-    # Fixed model
-    vision_model = "gemini-2.0-flash-exp"
-
+# Extract ECG readings from image using GPT-4.1
+def analyze_ecg_image(image):
     if image is None:
         return "<strong style='color:red'>No image provided.</strong>"
 
+    # Ensure OpenAI client is initialized
+    if openai_client is None:
+        return "<strong style='color:red'>OpenAI client not initialized. Check API Key.</strong>"
+
     # Ensure image is PIL Image
     if not isinstance(image, Image.Image):
         try:
-            # If 'image' is a path (from older Gradio versions or specific setups)
             if isinstance(image, str) and os.path.exists(image):
                  image = Image.open(image)
-            # If 'image' is file-like object from Gradio upload
             elif hasattr(image, 'name'):
                  image = Image.open(image.name)
             else:
-                 # Assume it might be bytes or needs loading differently
-                 # This part might need adjustment depending on how Gradio passes the image
                  return f"<strong style='color:red'>Unrecognized image input format: {type(image)}</strong>"
         except Exception as e:
              print(f"Error opening image:\n{traceback.format_exc()}")
              return f"<strong style='color:red'>Error opening image: {str(e)}</strong>"
 
-    # --- Gemini Specific Part ---
-    gemini_client = None # Initialize to None
     try:
-        # Get Gemini API Key
-        gemini_api_key = os.environ.get("GEMINI_API_KEY")
-        if not gemini_api_key:
-            return "<strong style='color:red'>GEMINI_API_KEY environment variable not set.</strong>"
-
-        # Initialize Gemini client
-        # Use Client() for explicit initialization per request (safer for concurrent use)
-        gemini_client = genai.Client(api_key=gemini_api_key)
-
-        # Convert PIL image to bytes (JPEG format)
-        buffered = io.BytesIO()
-        # Ensure image is in RGB format if it's RGBA or P which might cause issues
-        img_format = "JPEG"
-        if image.mode in ('RGBA', 'P'):
-            image = image.convert('RGB')
-        # Handle potential transparency issues for PNG -> JPEG conversion
-        elif image.mode == 'LA':
-             image = image.convert('RGB') # Convert Luminance Alpha to RGB
-        # Check format if needed
-        # if image.format == 'PNG': img_format = 'PNG' # Gemini might prefer JPEG? Test this.
-
-        image.save(buffered, format=img_format)
-        image_bytes = buffered.getvalue()
-
-        # Get current timestamp (computer time)
+        # Get current timestamp
         timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
-        # Create prompt for Gemini
-        vision_prompt = f"""Analyze this ECG image carefully. You are a cardiologist analyzing an electrocardiogram (ECG).
-
-        Extract and report all visible parameters and
-       
-        Report exact numerical values where visible. If a range is shown, report the range. Format your response using HTML list elements for better readability.
-
-        If certain measurements aren't clearly visible or determinable from the provided image quality, explicitly state that they cannot be determined.
-
-        If you notice any abnormalities or concerning patterns, highlight them clearly but avoid making definitive diagnoses. State observations neutrally.
+        # Convert image to base64
+        base64_image = encode_image(image)
+        if not base64_image:
+            return "<strong style='color:red'>Failed to encode image.</strong>"
 
+        # Create prompt for GPT-4.1
+        vision_prompt = f"""Analyze this ECG image carefully. You are a cardiologist analyzing an electrocardiogram (ECG).
+        
+        CRITICALLY IMPORTANT: Only report what you can actually see in this specific ECG image. Do not provide any predefined values or information not visible in the screen. If something cannot be determined from the image, explicitly state "Not determinable from image".
+        
+        Extract and report all visible parameters including:
+        - Heart rate
+        - Rhythm
+        - PR Interval
+        - QRS Duration
+        - QT/QTc Interval
+        - Axis
+        - P Waves characteristics
+        - ST Segment findings
+        - T Waves characteristics
+        - Any other measurements or values visible on the ECG
+        
+        Report exact numerical values where visible. If a range is shown, report the range.
+        
         Format your response strictly like this example:
         <h3>ECG Report</h3>
         <ul>
           <li><strong>Analysis Time:</strong> {timestamp}</li>
-          <li><strong>Heart Rate:</strong> [value] bpm (or 'Not determinable')</li>
-          <li><strong>Rhythm:</strong> [description] (or 'Not determinable')</li>
-          <li><strong>PR Interval:</strong> [value] ms (or 'Not determinable')</li>
-          <li><strong>QRS Duration:</strong> [value] ms (or 'Not determinable')</li>
-          <li><strong>QT/QTc Interval:</strong> [value]/[value] ms (or 'Not determinable')</li>
-          <li><strong>Axis:</strong> [description] (or 'Not determinable')</li>
-          <li><strong>P Waves:</strong> [description]</li>
-          <li><strong>ST Segment:</strong> [description]</li>
-          <li><strong>T Waves:</strong> [description]</li>
-          <!-- Add other relevant findings as list items -->
+          <li><strong>Heart Rate:</strong> [visible value] bpm (or 'Not determinable from image')</li>
+          <li><strong>Rhythm:</strong> [description] (or 'Not determinable from image')</li>
+          <li><strong>PR Interval:</strong> [visible value] ms (or 'Not determinable from image')</li>
+          <li><strong>QRS Duration:</strong> [visible value] ms (or 'Not determinable from image')</li>
+          <li><strong>QT/QTc Interval:</strong> [visible value]/[visible value] ms (or 'Not determinable from image')</li>
+          <li><strong>Axis:</strong> [description] (or 'Not determinable from image')</li>
+          <li><strong>P Waves:</strong> [description of what's visible]</li>
+          <li><strong>ST Segment:</strong> [description of what's visible]</li>
+          <li><strong>T Waves:</strong> [description of what's visible]</li>
+          <!-- Add other relevant findings visible in the image -->
         </ul>
-
-        <h3>Key Observations / Potential Abnormalities</h3>
+        <h3>Key Observations Based Only on What's Visible</h3>
         <ul>
-          <li>[Observation 1, e.g., Possible ST elevation in leads V1-V3]</li>
-          <li>[Observation 2, e.g., Inverted T waves in lead III]</li>
-          <!-- List significant observations, use <span style="color:red"> for critical findings -->
+          <li>[Only observations from what you can see in the image]</li>
+          <li>[Use <span style="color:red"> for critical visible findings only]</li>
         </ul>
-
-        <h3>Impression</h3>
-        <p>[Provide a brief summary impression based *only* on the visible findings, e.g., "Sinus tachycardia with possible anterior ST changes." Avoid definitive diagnosis.]</p>
-
+        <h3>Impression Based on Visible Findings</h3>
+        <p>[Provide a brief summary based ONLY on the visible findings in this ECG image]</p>
+        
         Important formatting instructions:
-        - Use EXACTLY the HTML structure shown (<h3>, <ul>, <li>, <strong>, <p>).
-        - Do NOT use markdown like asterisks (**) or hashtags (#). Use HTML tags for formatting.
-        - For potentially urgent findings in the 'Key Observations' list, wrap the description in <span style="color:red">text</span>.
+        - Use EXACTLY the HTML structure shown
+        - Do NOT use markdown formatting
+        - For urgent visible findings, wrap in <span style="color:red">text</span>
+        - Only comment on what you can actually see in the provided image
         """
 
-        # Generate content using Gemini
-        response = gemini_client.models.generate_content(
-            model=vision_model,
-            contents=[vision_prompt,
-                      types.Part.from_bytes(data=image_bytes, mime_type=f"image/{img_format.lower()}")]
-            # Add safety_settings if needed (BLOCK_NONE allows more content but use carefully):
-            # safety_settings=[
-            #     {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
-            #     {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
-            #     {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
-            #     {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
-            # ]
+        # Generate content using GPT-4.1
+        response = openai_client.responses.create(
+            model="gpt-4.1",
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        { "type": "input_text", "text": vision_prompt },
+                        {
+                            "type": "input_image",
+                            "image_url": f"data:image/jpeg;base64,{base64_image}",
+                        },
+                    ],
+                }
+            ],
+            max_tokens=2048
         )
 
-        # Handle potential blocks or errors in response
-        if not response.candidates:
-             feedback = getattr(response, 'prompt_feedback', None)
-             block_reason = getattr(feedback, 'block_reason', None) if feedback else None
-             if block_reason:
-                 return f"<strong style='color:red'>Analysis blocked by safety filter: {block_reason}. Consider adjusting safety settings or image content if appropriate.</strong>"
-             else:
-                 # Log the full response for debugging if possible
-                 print(f"Gemini Response Error: No candidates returned. Full response: {response}")
-                 return "<strong style='color:red'>No content generated by the model. The request might have been blocked, timed out, or failed unexpectedly. Check logs.</strong>"
-
-        # Accessing response text - check structure based on library version
-        try:
-            # Preferred way for recent versions
-            ecg_analysis = response.text
-        except ValueError:
-            # Fallback for potential older structures or errors
-             if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
-                 ecg_analysis = "".join(part.text for part in response.candidates[0].content.parts if hasattr(part, 'text'))
-             else:
-                 print(f"Gemini Response Error: Could not extract text. Response structure: {response}")
-                 return "<strong style='color:red'>Error processing model response. Unexpected format. Check logs.</strong>"
-
-
-        # --- End of Gemini Specific Part ---
+        ecg_analysis = response.output_text
 
-        # Basic post-processing (Gemini should follow HTML instructions, but just in case)
-        # Remove potential markdown that might slip through
+        # Basic post-processing to ensure HTML format
         ecg_analysis = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', ecg_analysis)
         ecg_analysis = re.sub(r'^\s*#+\s+(.*?)\s*$', r'<h3>\1</h3>', ecg_analysis, flags=re.MULTILINE)
-        ecg_analysis = re.sub(r'^\s*[\*-]\s+(.*?)\s*$', r'<li>\1</li>', ecg_analysis, flags=re.MULTILINE) # Convert markdown lists
+        ecg_analysis = re.sub(r'^\s*[\*-]\s+(.*?)\s*$', r'<li>\1</li>', ecg_analysis, flags=re.MULTILINE)
 
-        # Simple check if the response looks somewhat like the requested HTML structure
+        # Check if the response looks like the requested HTML structure
         if not ("<h3>" in ecg_analysis and "<ul>" in ecg_analysis):
-             print(f"Warning: Gemini response might not be in the expected HTML format:\n{ecg_analysis[:500]}...")
-             # Optionally wrap in basic tags if completely unformatted
-             # ecg_analysis = f"<h3>ECG Analysis (Raw Output)</h3><p>{ecg_analysis.replace('\n', '<br>')}</p>"
+             print(f"Warning: GPT-4.1 response might not be in the expected HTML format:\n{ecg_analysis[:500]}...")
 
         return ecg_analysis
 
     except Exception as e:
-        # Catch potential API errors or other issues
-        print(f"Error during Gemini ECG analysis:\n{traceback.format_exc()}")
+        print(f"Error during GPT-4.1 ECG analysis:\n{traceback.format_exc()}")
         error_type = type(e).__name__
-        return f"<strong style='color:red'>Error analyzing ECG image with Gemini ({error_type}):</strong> {str(e)}"
-    finally:
-        # Clean up client resource if necessary, though Client() might not require explicit closing
-        pass
-
+        return f"<strong style='color:red'>Error analyzing ECG image with GPT-4.1 ({error_type}):</strong> {str(e)}"
 
-# Generate medical assessment based on ECG readings and patient history (Uses Groq)
-def generate_assessment(ecg_analysis, patient_history=None, chat_model="llama3-70b-8192"): # Using a common Groq model
-    # Check Groq client initialization
-    if groq_client is None:
-        return "<strong style='color:red'>Groq client not initialized. Check API Key and startup logs.</strong>"
-
-    # Use a known available and capable Groq model
-    chat_model = "llama3-70b-8192" # Or "mixtral-8x7b-32768" or another available one
+# Generate medical assessment based on ECG readings and patient history
+def generate_assessment(ecg_analysis, patient_history=None):
+    if openai_client is None:
+        return "<strong style='color:red'>OpenAI client not initialized. Check API Key.</strong>"
 
     if not ecg_analysis or ecg_analysis.startswith("<strong style='color:red'>"):
         return "<strong style='color:red'>Cannot generate assessment. Please analyze a valid ECG image first.</strong>"
@@ -254,16 +209,15 @@ def generate_assessment(ecg_analysis, patient_history=None, chat_model="llama3-7
     # Get current timestamp
     timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
-    # Clean up potential HTML issues in the input ECG analysis for the prompt
-    # This helps prevent confusing the assessment model
-    clean_ecg_analysis = re.sub('<[^>]+>', '', ecg_analysis) # Strip HTML tags for the prompt context
+    # Clean up HTML tags for the prompt context
+    clean_ecg_analysis = re.sub('<[^>]+>', '', ecg_analysis)
 
     # Construct prompt based on available information
     prompt_parts = [
-        "You are a highly trained cardiologist assistant AI. Your task is to synthesize information from an ECG analysis and patient history (if provided) into a clinical assessment for a reviewing physician.",
+        "You are a highly trained cardiologist assistant AI. Synthesize information from the ECG analysis and patient history (if provided) into a clinical assessment.",
         "Focus on integrating the findings and suggesting potential implications and recommendations.",
         "Format your response strictly using the specified HTML structure.",
-        "\nECG ANALYSIS SUMMARY (Provided):\n" + clean_ecg_analysis, # Use cleaned text
+        "\nECG ANALYSIS SUMMARY (Provided):\n" + clean_ecg_analysis,
     ]
 
     if patient_history and patient_history.strip():
@@ -275,111 +229,87 @@ def generate_assessment(ecg_analysis, patient_history=None, chat_model="llama3-7
 
     prompt_parts.append("""
 Format your assessment using ONLY the following HTML structure:
-
 <h3>Summary of Integrated Findings</h3>
 <ul>
-  <li>[Combine key ECG findings with relevant patient history points, e.g., "ECG shows sinus tachycardia in the context of reported palpitations."]</li>
+  <li>[Combine key ECG findings with relevant patient history points]</li>
   <li>[Finding 2]</li>
-  <!-- etc. -->
 </ul>
-
 <h3>Key Abnormalities and Concerns</h3>
 <ul>
-  <li>[List specific significant abnormalities from the ECG, potentially contextualized by history, e.g., "ST elevation in anterior leads concerning for possible ischemia."]</li>
-  <li>[Abnormality 2 (if any)]</li>
-  <!-- Use <span style="color:red"> for urgent/critical concerns -->
+  <li>[List specific significant abnormalities from the ECG]</li>
+  <li>[Use <span style="color:red"> for urgent/critical concerns]</li>
 </ul>
-
 <h3>Potential Clinical Implications</h3>
 <ul>
-  <li>[Suggest possible underlying conditions or risks based on findings, e.g., "Findings could be consistent with acute coronary syndrome."]</li>
+  <li>[Suggest possible underlying conditions or risks]</li>
   <li>[Implication 2]</li>
-  <!-- etc. -->
 </ul>
-
 <h3>Recommendations for Physician Review</h3>
 <ul>
-  <li>[Suggest next steps or urgency, e.g., "<span style="color:red">Urgent clinical correlation and comparison with previous ECGs recommended.</span>"]</li>
-  <li>[Recommendation 2 (e.g., Consider further cardiac workup like troponins, echocardiogram if clinically indicated.)]</li>
-  <!-- etc. -->
+  <li>[Suggest next steps or urgency]</li>
+  <li>[Recommendation 2]</li>
 </ul>
-
 <h3>Differential Considerations (Optional)</h3>
 <ul>
-  <li>[List possible alternative explanations for the findings, if applicable.]</li>
+  <li>[List possible alternative explanations if applicable]</li>
   <li>[Differential 2]</li>
-  <!-- etc. -->
 </ul>
-
 Important Instructions:
-- Adhere strictly to the HTML format (<h3>, <ul>, <li>, <strong>, <p>, <span style="color:red">).
-- Do NOT use markdown formatting (**, #, - ).
-- Base your assessment ONLY on the provided ECG analysis and patient history.
-- Do NOT make a definitive diagnosis. Phrase conclusions as possibilities or suggestions for the physician.
-- If the ECG analysis indicated 'Not determinable' for key parameters, acknowledge this limitation.
+- Adhere strictly to the HTML format
+- Do NOT use markdown formatting
+- Base your assessment ONLY on the provided information
+- Do NOT make definitive diagnoses
 """)
     prompt = "\n".join(prompt_parts)
 
     try:
-        assessment_completion = groq_client.chat.completions.create(
-            messages=[
+        assessment_completion = openai_client.responses.create(
+            model="gpt-4.1",
+            input=[
                 {
                     "role": "system",
                     "content": "You are a medical AI assistant specialized in cardiology. Generate a structured clinical assessment based on the provided ECG and patient data, formatted in HTML for physician review. Highlight urgent findings appropriately. Avoid definitive diagnoses."
                 },
                 {
                     "role": "user",
-                    "content": prompt
+                    "content": [{"type": "input_text", "text": prompt}]
                 }
             ],
-            model=chat_model,
-            temperature=0.2,
-            max_tokens=2048, # Adjust as needed
-            # top_p=0.9, # Optional parameter tuning
-            # stop=None, # Optional stop sequences
+            max_tokens=2048
         )
 
-        assessment_text = assessment_completion.choices[0].message.content
+        assessment_text = assessment_completion.output_text
 
-        # Basic post-processing (Groq should follow HTML instructions, but good to have fallbacks)
+        # Basic post-processing
         assessment_text = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', assessment_text)
         assessment_text = re.sub(r'^\s*#+\s+(.*?)\s*$', r'<h3>\1</h3>', assessment_text, flags=re.MULTILINE)
 
-        # *** CORRECTED FALLBACK LOGIC ***
-        # Check if the response seems to contain the expected HTML structure
+        # Check if the response contains the expected HTML structure
         if not ("<h3>" in assessment_text and "<ul>" in assessment_text):
-            print(f"Warning: Groq assessment response might not be in the expected HTML format:\n{assessment_text[:500]}...")
-            # Fallback: Wrap the raw text in a paragraph tag with line breaks
+            print(f"Warning: GPT-4.1 assessment response might not be in the expected HTML format:\n{assessment_text[:500]}...")
             processed_text = assessment_text.replace('\n', '<br>')
             assessment_text = f"<h3>Assessment (Raw Output)</h3><p>{processed_text}</p>"
 
         return assessment_text
 
     except Exception as e:
-        print(f"Error during Groq assessment generation:\n{traceback.format_exc()}")
+        print(f"Error during GPT-4.1 assessment generation:\n{traceback.format_exc()}")
         error_type = type(e).__name__
-        return f"<strong style='color:red'>Error generating assessment with Groq ({error_type}):</strong> {str(e)}"
-
-
-# Doctor's chat interaction with the model about the patient (Uses Groq)
-def doctor_chat(message, chat_history, ecg_analysis, patient_history, assessment, chat_model="llama3-70b-8192"):
-    # Check Groq client initialization
-    if groq_client is None:
-        # Prepend error message to history instead of returning it directly
-        chat_history.append((message, "<strong style='color:red'>Cannot start chat. Groq client not initialized. Check API Key.</strong>"))
-        return "", chat_history # Clear input, update history
+        return f"<strong style='color:red'>Error generating assessment with GPT-4.1 ({error_type}):</strong> {str(e)}"
 
-    # Fixed model
-    chat_model = "llama3-70b-8192" # Consistent with assessment
+# Doctor's chat interaction with the model about the patient
+def doctor_chat(message, chat_history, ecg_analysis, patient_history, assessment):
+    if openai_client is None:
+        chat_history.append((message, "<strong style='color:red'>Cannot start chat. OpenAI client not initialized. Check API Key.</strong>"))
+        return "", chat_history
 
     # Check if ECG analysis exists and is not an error message
     if not ecg_analysis or ecg_analysis.startswith("<strong style='color:red'>"):
-        # Prepend error message to history
         chat_history.append((message, "<strong style='color:red'>Cannot start chat. Please analyze a valid ECG image first.</strong>"))
-        return "", chat_history # Clear input, update history
+        return "", chat_history
 
     if not message.strip():
-        return "", chat_history # Ignore empty messages
+        return "", chat_history
 
     # Get current timestamp
     timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
@@ -391,18 +321,14 @@ def doctor_chat(message, chat_history, ecg_analysis, patient_history, assessment
 
     # Prepare chat context
     context = f"""CURRENT TIMESTAMP: {timestamp}
-
 === BEGIN PATIENT CONTEXT ===
 PATIENT HISTORY:
 {clean_history}
-
 ECG ANALYSIS SUMMARY:
 {clean_ecg}
-
 GENERATED ASSESSMENT SUMMARY:
 {clean_assessment}
 === END PATIENT CONTEXT ===
-
 Based *only* on the patient context provided above, answer the doctor's questions concisely and professionally. If the information needed to answer is not in the context, explicitly state that. Do not invent information or access external knowledge.
 """
 
@@ -414,39 +340,37 @@ Based *only* on the patient context provided above, answer the doctor's question
         }
     ]
 
-    # Add chat history to the context (limited number of turns to manage token count)
-    history_limit = 5 # Number of past user/assistant pairs
+    # Add chat history to the context
+    history_limit = 5
     for user_msg, assistant_msg in chat_history[-history_limit:]:
-        messages.append({"role": "user", "content": user_msg})
-        # Avoid adding error messages from assistant back into context
+        messages.append({"role": "user", "content": [{"type": "input_text", "text": user_msg}]})
         if isinstance(assistant_msg, str) and not assistant_msg.startswith("<strong style='color:red'>"):
              messages.append({"role": "assistant", "content": assistant_msg})
 
     # Add the current message
-    messages.append({"role": "user", "content": message})
+    messages.append({"role": "user", "content": [{"type": "input_text", "text": message}]})
 
     try:
-        chat_completion = groq_client.chat.completions.create(
-            messages=messages,
-            model=chat_model,
-            temperature=0.3, # Slightly higher for more conversational answers, but still factual
-            max_tokens=1024, # Adjust as needed
+        chat_completion = openai_client.responses.create(
+            model="gpt-4.1",
+            input=messages,
+            max_tokens=1024
         )
 
-        response = chat_completion.choices[0].message.content
+        response = chat_completion.output_text
 
-        # Basic post-processing for the chat response (less critical for HTML here)
-        response = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', response) # Convert bold markdown
-        response = response.replace('\n', '<br>') # Ensure line breaks are rendered in HTML chatbot
+        # Basic post-processing for the chat response
+        response = re.sub(r'\*\*(.*?)\*\*', r'<strong>\1</strong>', response)
+        response = response.replace('\n', '<br>')
 
         chat_history.append((message, response))
-        return "", chat_history # Clear input message box
+        return "", chat_history
     except Exception as e:
-        print(f"Error during Groq chat:\n{traceback.format_exc()}")
+        print(f"Error during GPT-4.1 chat:\n{traceback.format_exc()}")
         error_type = type(e).__name__
         error_message = f"<strong style='color:red'>Error in chat ({error_type}):</strong> {str(e)}"
         chat_history.append((message, error_message))
-        return "", chat_history # Clear input message box
+        return "", chat_history
 
 # Create Gradio interface
 with gr.Blocks(title="Cardiac ECG Analysis System", theme=gr.themes.Soft()) as app:
@@ -462,7 +386,7 @@ with gr.Blocks(title="Cardiac ECG Analysis System", theme=gr.themes.Soft()) as a
                     with gr.Group():
                         gr.Markdown("### 📊 ECG Image Upload")
                         ecg_image = gr.Image(type="pil", label="Upload ECG Image", height=300)
-                        gr.Markdown("**Vision Model**")
+                        gr.Markdown("**Vision Model: GPT-4.1**")
                         analyze_button = gr.Button("Analyze ECG Image", variant="primary")
 
                     with gr.Group():
@@ -470,7 +394,7 @@ with gr.Blocks(title="Cardiac ECG Analysis System", theme=gr.themes.Soft()) as a
                         patient_history_text = gr.Textbox(
                             lines=8,
                             label="Patient History (Manual Entry or Loaded from File)",
-                            placeholder="Enter relevant patient details (age, sex, symptoms, meds, conditions) OR upload a file (.txt, .csv, .xlsx) and click Load."
+                            placeholder="Enter relevant patient details OR upload a file and click Load."
                         )
                         patient_history_file = gr.File(
                             label="Upload Patient History File (Optional)",
@@ -480,8 +404,7 @@ with gr.Blocks(title="Cardiac ECG Analysis System", theme=gr.themes.Soft()) as a
 
                     with gr.Group():
                         gr.Markdown("### 🧠 Generate Assessment")
-                        # Ensure this model name matches the one used in generate_assessment/doctor_chat
-                        gr.Markdown("**Assessment/Chat Model**")
+                        gr.Markdown("**Assessment/Chat Model: GPT-4.1**")
                         assess_button = gr.Button("Generate Assessment", variant="primary")
 
                 with gr.Column(scale=1):
@@ -494,7 +417,7 @@ with gr.Blocks(title="Cardiac ECG Analysis System", theme=gr.themes.Soft()) as a
                         gr.Markdown("### 📝 Medical Assessment")
                         assessment_output = gr.HTML(label="Assessment", elem_id="assessment-output")
 
-            gr.Markdown("---") # Separator
+            gr.Markdown("---")
             gr.Markdown("## 👨‍⚕️ Doctor's Consultation Chat")
             gr.Markdown("Ask follow-up questions based on the analysis and assessment above.")
 
@@ -503,14 +426,14 @@ with gr.Blocks(title="Cardiac ECG Analysis System", theme=gr.themes.Soft()) as a
                     label="Consultation Log",
                     height=450,
                     bubble_full_width=False,
-                    show_label=False # Label provided by Markdown above
+                    show_label=False
                 )
                 with gr.Row():
                     message = gr.Textbox(
-                        label="Your Question", # Added label for clarity
+                        label="Your Question",
                         placeholder="Type your question here and press Enter or click Send...",
                         scale=4,
-                        show_label=False, # Hide label visually if desired, but keep for accessibility
+                        show_label=False,
                         container=False,
                     )
                     chat_button = gr.Button("Send", scale=1, variant="primary")
@@ -518,67 +441,54 @@ with gr.Blocks(title="Cardiac ECG Analysis System", theme=gr.themes.Soft()) as a
         with gr.TabItem("ℹ️ Instructions & Disclaimer"):
             gr.Markdown("""
             ## How to Use This Application
-
             1.  **Upload ECG:** Go to the "Main Interface" tab. Upload an ECG image using the designated area.
-            2.  **Analyze ECG:** Click the **Analyze ECG Image** button. Wait for the results to appear in the "ECG Analysis Results" box. This uses the Gemini model.
+            2.  **Analyze ECG:** Click the **Analyze ECG Image** button. The system will analyze using GPT-4.1 and show results.
             3.  **Add Patient History (Optional):**
                 *   Type relevant details directly into the "Patient History" text box.
-                *   OR, upload a `.txt`, `.csv`, or `.xlsx` file containing patient info and click **Load Patient History from File**. The content will load into the text box.
-            4.  **Generate Assessment:** Click the **Generate Assessment** button. The system will combine the ECG analysis and patient history (if provided) to generate a structured assessment using a Llama model via Groq. Results appear in the "Medical Assessment" box.
-            5.  **Consult:** Use the chat interface at the bottom to ask follow-up questions. Type your question and click **Send** or press Enter. The chat uses the Llama model via Groq and considers the context provided above it.
-
+                *   OR, upload a `.txt`, `.csv`, or `.xlsx` file and click **Load Patient History from File**.
+            4.  **Generate Assessment:** Click the **Generate Assessment** button. Results appear in the "Medical Assessment" box.
+            5.  **Consult:** Use the chat interface to ask follow-up questions about the analysis and assessment.
             ---
             ## Important Disclaimer
-
-            *   **Not a Medical Device:** This tool is for informational purposes only. It is **NOT** a certified medical device and should **NOT** be used for primary diagnosis, treatment decisions, or emergency situations.
-            *   **AI Limitations:** AI models can make mistakes, misinterpret images, or generate inaccurate information. The outputs are not a substitute for professional medical expertise.
-            *   **Professional Judgment Required:** All outputs must be critically reviewed and verified by a qualified healthcare professional in the context of the patient's overall clinical picture. Do not rely solely on the AI's interpretation.
+            *   **Not a Medical Device:** This tool is for informational purposes only. It is **NOT** a certified medical device.
+            *   **AI Limitations:** AI models can make mistakes, misinterpret images, or generate inaccurate information.
+            *   **Professional Judgment Required:** All outputs must be reviewed by a qualified healthcare professional.
             *   **No Liability:** Use this tool at your own risk. The creators assume no liability for any decisions made based on its output.
             """)
 
-    # --- Event Handlers ---
-
-    # Analyze Button: Input ECG Image -> Output ECG Analysis HTML
+    # Event Handlers
     analyze_button.click(
         fn=analyze_ecg_image,
         inputs=[ecg_image],
         outputs=ecg_analysis_output
     )
 
-    # Load History Button: Input File -> Output Text into History Textbox
     load_history_button.click(
         fn=process_patient_history,
         inputs=[patient_history_file],
         outputs=[patient_history_text]
     )
 
-    # Assess Button: Input ECG Analysis HTML, History Text -> Output Assessment HTML
     assess_button.click(
         fn=generate_assessment,
         inputs=[ecg_analysis_output, patient_history_text],
         outputs=assessment_output
     )
 
-    # Chat Send Button: Input Message, Chat History, Context -> Output Cleared Message, Updated Chat History
     chat_button.click(
         fn=doctor_chat,
         inputs=[message, chatbot, ecg_analysis_output, patient_history_text, assessment_output],
         outputs=[message, chatbot]
     )
 
-    # Chat Textbox Submit (Enter): Input Message, Chat History, Context -> Output Cleared Message, Updated Chat History
     message.submit(
         fn=doctor_chat,
         inputs=[message, chatbot, ecg_analysis_output, patient_history_text, assessment_output],
         outputs=[message, chatbot]
     )
 
-
 # Launch the app
 if __name__ == "__main__":
     print("===== Application Startup =====")
     print(f"Attempting to launch Gradio app at {datetime.datetime.now()}")
-    # Add share=True for a temporary public link (use with caution regarding data privacy)
-    # Add debug=True for more detailed error output during development
-    app.launch()
-    # app.launch(share=True, debug=True)
+    app.launch()