Update app.py with effective Groq API integration

app.py

@@ -1,42 +1,35 @@
 import os
-import numpy as np
-import tensorflow as tf
-from tensorflow.keras.preprocessing import image
 import gradio as gr
+import numpy as np
 import requests
 import json
+from dotenv import load_dotenv
+from tensorflow.keras.models import load_model
+from PIL import Image
 
-# Suppress TensorFlow warnings
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
-device = "cuda" if tf.test.is_gpu_available() else "cpu"
-print(f"Running on: {device.upper()}")
+# Load environment variables
+load_dotenv()
 
-# Groq API key for AI assistant
-GROQ_API_KEY = "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"
+# ===== Groq API Key =====
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "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")
 GROQ_MODEL = "llama3-70b-8192"  # Using Llama 3 70B model
+print(f"Groq API key available: {'Yes' if GROQ_API_KEY else 'No'}")
 
-# Fallback to Hugging Face token if Groq fails
-HF_API_TOKEN = os.getenv("HUGGINGFACE_TOKEN")
-print(f"API tokens available: Groq=Yes, HF={'Yes' if HF_API_TOKEN else 'No'}")
-
-# Load the trained tomato disease detection model
-model = tf.keras.models.load_model("Tomato_Leaf_Disease_Model.h5")
+# ===== Fallback to Hugging Face API Token =====
+HF_API_TOKEN = os.getenv("HF_API_TOKEN")
+print(f"HF API token available: {'Yes' if HF_API_TOKEN else 'No'}")
 
-# Disease categories
-class_labels = [
-    "Tomato Bacterial Spot",
-    "Tomato Early Blight",
-    "Tomato Late Blight",
-    "Tomato Mosaic Virus",
-    "Tomato Yellow Leaf Curl Virus"
-]
+# ===== Load Trained Models =====
+model_a = load_model("Tomato_Leaf_Disease_Model.h5")
+model_b = load_model("tomato_leaf_model_final(77%).h5")
+classifier_model = load_model("tomato_leaf_classifier_optimized.h5")
 
-# Disease information database (fallback if API fails)
+# ===== Disease Information Database (fallback if API fails) =====
 disease_info = {
     "Tomato Bacterial Spot": {
         "description": "A bacterial disease that causes small, dark spots on leaves, stems, and fruits.",
         "causes": "Caused by Xanthomonas bacteria, spread by water splash, contaminated tools, and seeds.",
-        "recommendations": [
+        "treatment": [
             "Remove and destroy infected plants",
             "Rotate crops with non-solanaceous plants",
             "Use copper-based fungicides",
@@ -46,7 +39,7 @@ disease_info = {
     "Tomato Early Blight": {
         "description": "A fungal disease that causes dark spots with concentric rings on lower leaves first.",
         "causes": "Caused by Alternaria solani fungus, favored by warm, humid conditions.",
-        "recommendations": [
+        "treatment": [
             "Remove infected leaves promptly",
             "Improve air circulation around plants",
             "Apply fungicides preventatively",
@@ -56,7 +49,7 @@ disease_info = {
     "Tomato Late Blight": {
         "description": "A devastating fungal disease that causes dark, water-soaked lesions on leaves and fruits.",
         "causes": "Caused by Phytophthora infestans, favored by cool, wet conditions.",
-        "recommendations": [
+        "treatment": [
             "Remove and destroy infected plants immediately",
             "Apply fungicides preventatively in humid conditions",
             "Improve drainage and air circulation",
@@ -66,7 +59,7 @@ disease_info = {
     "Tomato Mosaic Virus": {
         "description": "A viral disease that causes mottled green/yellow patterns on leaves and stunted growth.",
         "causes": "Caused by tobacco mosaic virus (TMV), spread by handling, tools, and sometimes seeds.",
-        "recommendations": [
+        "treatment": [
             "Remove and destroy infected plants",
             "Wash hands and tools after handling infected plants",
             "Control insect vectors like aphids",
@@ -76,44 +69,106 @@ disease_info = {
     "Tomato Yellow Leaf Curl Virus": {
         "description": "A viral disease transmitted by whiteflies that causes yellowing and curling of leaves.",
         "causes": "Caused by a begomovirus, transmitted primarily by whiteflies.",
-        "recommendations": [
+        "treatment": [
             "Use whitefly control measures",
             "Remove and destroy infected plants",
             "Use reflective mulches to repel whiteflies",
             "Plant resistant varieties"
         ]
+    },
+    "Tomato___Target_Spot": {
+        "description": "A fungal disease causing circular lesions with concentric rings on leaves, stems, and fruits.",
+        "causes": "Caused by Corynespora cassiicola fungus, favored by warm, humid conditions.",
+        "treatment": [
+            "Remove infected plant parts",
+            "Improve air circulation",
+            "Apply fungicides at first sign of disease",
+            "Avoid overhead irrigation"
+        ]
+    },
+    "Tomato___Bacterial_spot": {
+        "description": "A bacterial disease causing small, dark, water-soaked spots on leaves, stems, and fruits.",
+        "causes": "Caused by Xanthomonas species, spread by water splash and contaminated tools.",
+        "treatment": [
+            "Remove infected plant debris",
+            "Use copper-based bactericides",
+            "Rotate crops",
+            "Use disease-free seeds and transplants"
+        ]
+    },
+    "Tomato___healthy": {
+        "description": "The plant shows no signs of disease and appears to be in good health.",
+        "causes": "Proper growing conditions, good management practices, and disease prevention.",
+        "treatment": [
+            "Continue regular watering and fertilization",
+            "Monitor for early signs of disease",
+            "Maintain good air circulation",
+            "Practice crop rotation"
+        ]
     }
 }
 
-# Image preprocessing function
-def preprocess_image(img):
-    img = img.resize((224, 224))  # Resize for model input
-    img = image.img_to_array(img) / 255.0  # Normalize
-    return np.expand_dims(img, axis=0)  # Add batch dimension
-
-# Temperature Scaling: Adjusts predictions using a temperature parameter.
-def apply_temperature_scaling(prediction, temperature):
-    # Avoid log(0) by adding a small epsilon
-    eps = 1e-8
-    scaled_logits = np.log(np.maximum(prediction, eps)) / temperature
-    exp_logits = np.exp(scaled_logits)
-    scaled_probs = exp_logits / np.sum(exp_logits)
-    return scaled_probs
+# ===== Preprocessing Function =====
+def preprocess_image(image, target_size=(224, 224)):
+    # Ensure the image is resized and normalized.
+    if isinstance(image, Image.Image):
+        img = image.resize(target_size)
+    else:
+        img = Image.fromarray(image).resize(target_size)
+    img_array = np.array(img) / 255.0
+    img_array = np.expand_dims(img_array, axis=0)
+    return img_array
+
+# ===== Disease Label Mappings =====
+# Model A labels
+disease_labels_a = {
+    0: "Tomato Bacterial Spot",
+    1: "Tomato Early Blight",
+    2: "Tomato Late Blight",
+    3: "Tomato Mosaic Virus",
+    4: "Tomato Yellow Leaf Curl Virus"
+}
 
-# Min-Max Normalization: Scales the raw confidence based on provided min and max values.
-def apply_min_max_scaling(confidence, min_conf, max_conf):
-    norm = (confidence - min_conf) / (max_conf - min_conf) * 100
-    norm = np.clip(norm, 0, 100)
-    return norm
+# Model B labels
+disease_labels_b = {
+    0: "Tomato___Target_Spot",
+    1: "Tomato___Bacterial_spot",
+    2: "Tomato___Early_blight",
+    3: "Tomato___healthy",
+    4: "Tomato___Late_blight"
+}
 
-# Call Groq API for AI assistant
+# ===== Prediction Functions =====
+def predict_model_a(image):
+    img = preprocess_image(image)
+    pred = model_a.predict(img)
+    predicted_class = np.argmax(pred)
+    confidence = float(np.max(pred) * 100)
+    return disease_labels_a.get(predicted_class, "Unknown result"), confidence
+
+def predict_model_b(image):
+    img = preprocess_image(image)
+    pred = model_b.predict(img)
+    predicted_class = np.argmax(pred)
+    confidence = float(np.max(pred) * 100)
+    return disease_labels_b.get(predicted_class, "Unknown result"), confidence
+
+def predict_classifier(image):
+    img = preprocess_image(image)
+    pred = classifier_model.predict(img)
+    # Here we assume the classifier returns class 1 for "Tomato Leaf"
+    return "Tomato Leaf" if np.argmax(pred) == 1 else "Not Tomato Leaf"
+
+# ===== Groq API Call =====
 def call_groq_api(prompt):
     """Call Groq API for detailed disease analysis and advice"""
+    print(f"Calling Groq API with prompt: {prompt[:50]}...")
+    
     headers = {
         "Authorization": f"Bearer {GROQ_API_KEY}",
         "Content-Type": "application/json"
     }
-
+    
     payload = {
         "model": GROQ_MODEL,
         "messages": [
@@ -123,7 +178,7 @@ def call_groq_api(prompt):
         "max_tokens": 800,
         "temperature": 0.7
     }
-
+    
     try:
         response = requests.post(
             "https://api.groq.com/openai/v1/chat/completions",
@@ -131,30 +186,34 @@ def call_groq_api(prompt):
             json=payload,
             timeout=30
         )
-
+        
+        print(f"Groq API response status: {response.status_code}")
+        
         if response.status_code == 200:
             result = response.json()
             if "choices" in result and len(result["choices"]) > 0:
-                return result["choices"][0]["message"]["content"]
-
+                content = result["choices"][0]["message"]["content"]
+                print(f"Groq API response received: {len(content)} characters")
+                return content
+        
         print(f"Groq API error: {response.status_code} - {response.text}")
         return None
-
+    
     except Exception as e:
         print(f"Error with Groq API: {str(e)}")
         return None
 
-# Fallback to Hugging Face if Groq fails
-def call_hf_model(prompt, model_id="mistralai/Mistral-7B-Instruct-v0.2"):
-    """Call an AI model on Hugging Face for detailed disease analysis."""
+# ===== Fallback to Hugging Face API =====
+def call_hf_api(prompt, model_id="mistralai/Mistral-7B-Instruct-v0.2"):
+    """Call Hugging Face API as fallback"""
     if not HF_API_TOKEN:
         return None
-
+    
     headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
-
+    
     # Format prompt for instruction-tuned models
     formatted_prompt = f"""<s>[INST] {prompt} [/INST]"""
-
+    
     payload = {
         "inputs": formatted_prompt,
         "parameters": {
@@ -164,12 +223,12 @@ def call_hf_model(prompt, model_id="mistralai/Mistral-7B-Instruct-v0.2"):
             "do_sample": True
         }
     }
-
+    
     url = f"https://api-inference.huggingface.co/models/{model_id}"
-
+    
     try:
         response = requests.post(url, headers=headers, json=payload, timeout=30)
-
+        
         if response.status_code == 200:
             result = response.json()
             if isinstance(result, list) and len(result) > 0:
@@ -179,193 +238,261 @@ def call_hf_model(prompt, model_id="mistralai/Mistral-7B-Instruct-v0.2"):
                     # Remove the prompt from the response
                     response_text = generated_text.split("[/INST]")[-1].strip()
                     return response_text
-
+        
         return None
-
+    
     except Exception as e:
-        print(f"Exception when calling HF model: {str(e)}")
+        print(f"Error with Hugging Face API: {str(e)}")
         return None
 
-# Combined AI model call with fallback
-def call_ai_model(prompt):
-    """Call AI models with fallback mechanisms"""
-    # Try Groq first
+# ===== AI Assistant Functions =====
+def ai_assistant_v1(image, prediction, confidence):
+    """Use Groq API for Model A versions"""
+    if "healthy" in prediction.lower():
+        prompt = (
+            "You are an agricultural advisor speaking to a farmer. "
+            "The tomato crop appears healthy. "
+            "Provide detailed preventive tips and best practices for maintaining tomato crop health. "
+            "Include information about watering, fertilization, pest prevention, and optimal growing conditions. "
+            "Format your response in clear sections with bullet points where appropriate."
+        )
+    else:
+        prompt = (
+            f"You are an agricultural advisor speaking to a farmer. "
+            f"A disease has been detected in their tomato crop: {prediction} with {confidence:.1f}% confidence. "
+            f"Provide detailed advice on how to identify, manage and treat this disease. "
+            f"Include information about: "
+            f"1) What causes this disease "
+            f"2) How it spreads "
+            f"3) Specific treatments (both organic and chemical options) "
+            f"4) Preventive measures for the future "
+            f"Format your response in clear sections with bullet points where appropriate."
+        )
+    
+    # Call Groq API
     response = call_groq_api(prompt)
-    if response:
-        return response
-
-    # If Groq fails, try Hugging Face
-    response = call_hf_model(prompt)
-    if response:
-        return response
-
-    # If both fail, return fallback message
-    return "Sorry, I'm having trouble connecting to the AI service. Using fallback information instead."
-
-# Generate AI response for disease analysis
-def generate_ai_response(disease_name, confidence):
-    """Generate a detailed AI response about the detected disease."""
-    # Get fallback information in case AI call fails
-    info = disease_info.get(disease_name, {
-        "description": "Information not available for this disease.",
-        "causes": "Unknown causes.",
-        "recommendations": ["Consult with a local agricultural extension service."]
-    })
-
-    # Create prompt for AI model
-    prompt = (
-        f"You are an agricultural expert advisor. A tomato plant disease has been detected: {disease_name} "
-        f"with {confidence:.2f}% confidence. "
-        f"Provide a detailed analysis including: "
-        f"1) A brief description of the disease "
-        f"2) What causes it and how it spreads "
-        f"3) The impact on tomato plants and yield "
-        f"4) Detailed treatment options (both organic and chemical) "
-        f"5) Prevention strategies for future crops "
-        f"Format your response in clear sections with bullet points where appropriate."
-    )
-
-    # Call AI model with fallback mechanisms
-    ai_response = call_ai_model(prompt)
-
-    # If AI response contains error message, use fallback information
-    if "Sorry, I'm having trouble" in ai_response:
-        ai_response = f"""
-# Disease: {disease_name}
+    
+    # If Groq API fails, try Hugging Face API
+    if not response:
+        response = call_hf_api(prompt)
+    
+    # If both APIs fail, use fallback information
+    if not response:
+        # Get fallback information from our database
+        info = disease_info.get(prediction, {
+            "description": "Information not available for this disease.",
+            "causes": "Unknown causes.",
+            "treatment": ["Consult with a local agricultural extension service."]
+        })
+        
+        response = f"""
+# {prediction}
 
 ## Description
-{info['description']}
+{info.get('description', 'No description available.')}
 
 ## Causes
 {info.get('causes', 'Information not available.')}
 
 ## Recommended Treatment
-{chr(10).join(f"- {rec}" for rec in info['recommendations'])}
+{chr(10).join(f"- {rec}" for rec in info.get('treatment', ['No specific treatment information available.']))}
 
 *Note: This is fallback information. For more detailed advice, please try again later when the AI service is available.*
 """
+    
+    return response
+
+def ai_assistant_v2(image, prediction, confidence):
+    """Use Groq API for Model B versions"""
+    if "healthy" in prediction.lower():
+        prompt = (
+            "You are an agricultural advisor speaking to a farmer. "
+            "The tomato crop appears healthy. "
+            "Provide detailed preventive tips and best practices for maintaining tomato crop health. "
+            "Include information about watering, fertilization, pest prevention, and optimal growing conditions. "
+            "Format your response in clear sections with bullet points where appropriate."
+        )
+    else:
+        prompt = (
+            f"You are an agricultural advisor speaking to a farmer. "
+            f"A disease has been detected in their tomato crop: {prediction} with {confidence:.1f}% confidence. "
+            f"Provide detailed advice on how to identify, manage and treat this disease. "
+            f"Include information about: "
+            f"1) What causes this disease "
+            f"2) How it spreads "
+            f"3) Specific treatments (both organic and chemical options) "
+            f"4) Preventive measures for the future "
+            f"Format your response in clear sections with bullet points where appropriate."
+        )
+    
+    # Call Groq API
+    response = call_groq_api(prompt)
+    
+    # If Groq API fails, try Hugging Face API
+    if not response:
+        response = call_hf_api(prompt)
+    
+    # If both APIs fail, use fallback information
+    if not response:
+        # Get fallback information from our database
+        info = disease_info.get(prediction, {
+            "description": "Information not available for this disease.",
+            "causes": "Unknown causes.",
+            "treatment": ["Consult with a local agricultural extension service."]
+        })
+        
+        response = f"""
+# {prediction}
 
-    return ai_response
-
-# Chat with agricultural expert
-def chat_with_expert(message, chat_history):
-    """Handle chat interactions with farmers about agricultural topics."""
-    if not message.strip():
-        return "", chat_history
-
-    # Prepare context from chat history - use last 3 exchanges for context to avoid token limits
-    context = "\n".join([f"Farmer: {q}\nExpert: {a}" for q, a in chat_history[-3:]])
-
-    prompt = (
-        f"You are an expert agricultural advisor specializing in tomato farming and plant diseases. "
-        f"You provide helpful, accurate, and practical advice to farmers. "
-        f"Always be respectful and considerate of farmers' knowledge while providing expert guidance. "
-        f"If you're unsure about something, acknowledge it and provide the best information you can. "
-        f"Previous conversation:\n{context}\n\n"
-        f"Farmer's new question: {message}\n\n"
-        f"Provide a helpful, informative response about farming, focusing on tomatoes if relevant."
-    )
-
-    # Call AI model with fallback mechanisms
-    response = call_ai_model(prompt)
-
-    # If AI response contains error message, use fallback response
-    if "Sorry, I'm having trouble" in response:
-        response = "I apologize, but I'm having trouble connecting to my knowledge base at the moment. Please try again later, or ask a different question about tomato farming or plant diseases."
+## Description
+{info.get('description', 'No description available.')}
 
-    chat_history.append((message, response))
-    return "", chat_history
+## Causes
+{info.get('causes', 'Information not available.')}
 
-# Main detection function with adjustable confidence scaling
-def detect_disease_scaled(img, scaling_method, temperature, min_conf, max_conf):
-    processed_img = preprocess_image(img)
-    prediction = model.predict(processed_img)[0]  # Get prediction for single image
-    raw_confidence = np.max(prediction) * 100
-    class_idx = np.argmax(prediction)
-    disease_name = class_labels[class_idx]
+## Recommended Treatment
+{chr(10).join(f"- {rec}" for rec in info.get('treatment', ['No specific treatment information available.']))}
 
-    if scaling_method == "Temperature Scaling":
-        scaled_probs = apply_temperature_scaling(prediction, temperature)
-        adjusted_confidence = np.max(scaled_probs) * 100
-    elif scaling_method == "Min-Max Normalization":
-        adjusted_confidence = apply_min_max_scaling(raw_confidence, min_conf, max_conf)
+*Note: This is fallback information. For more detailed advice, please try again later when the AI service is available.*
+"""
+    
+    return response
+
+# ===== Process Function Based on Version =====
+def process_version(image, version):
+    if image is None:
+        return "No image provided."
+    
+    # --- Version 1.x (Model A) ---
+    if version == "1.1":
+        result, confidence = predict_model_a(image)
+        return f"Model A Prediction: {result} (Confidence: {confidence:.1f}%)\n\nView Model A Training Notebook: https://colab.research.google.com/drive/1FMjs7JmdO6WVoXbzLA-ymwnIKq-GaV6w?usp=sharing"
+    
+    elif version == "1.2":
+        result, confidence = predict_model_a(image)
+        advice = ai_assistant_v1(image, result, confidence)
+        return f"Model A Prediction: {result} (Confidence: {confidence:.1f}%)\n\nExpert Advice:\n{advice}"
+    
+    elif version == "1.3":
+        cls_result = predict_classifier(image)
+        if cls_result != "Tomato Leaf":
+            return "Classifier: The image is not a tomato leaf. Please try again with a tomato leaf image."
+        
+        result, confidence = predict_model_a(image)
+        advice = ai_assistant_v1(image, result, confidence)
+        return (
+            f"Classifier: {cls_result}\n"
+            f"Model A Prediction: {result} (Confidence: {confidence:.1f}%)\n\n"
+            f"Expert Advice:\n{advice}\n\n"
+            f"[View Model A & Classifier Training Notebook](https://colab.research.google.com/drive/1FMjs7JmdO6WVoXbzLA-ymwnIKq-GaV6w?usp=sharing)"
+        )
+    
+    # --- Version 2.x (Model B) ---
+    elif version == "2.1":
+        result, confidence = predict_model_b(image)
+        return f"Model B Prediction: {result} (Confidence: {confidence:.1f}%)\n\n[View Model B Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)"
+    
+    elif version == "2.2":
+        result, confidence = predict_model_b(image)
+        advice = ai_assistant_v2(image, result, confidence)
+        return f"Model B Prediction: {result} (Confidence: {confidence:.1f}%)\n\nExpert Advice:\n{advice}"
+    
+    elif version == "2.3":
+        cls_result = predict_classifier(image)
+        if cls_result != "Tomato Leaf":
+            return "Classifier: The image is not a tomato leaf. Please try again with a tomato leaf image."
+        
+        result, confidence = predict_model_b(image)
+        advice = ai_assistant_v2(image, result, confidence)
+        return (
+            f"Classifier: {cls_result}\n"
+            f"Model B Prediction: {result} (Confidence: {confidence:.1f}%)\n\n"
+            f"Expert Advice:\n{advice}\n\n"
+            f"[View Model B & Classifier Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)"
+        )
+    
     else:
-        adjusted_confidence = raw_confidence
+        return "Invalid version selected."
+
+# ===== Helper Function to Choose Between Uploaded & Camera Image =====
+def combine_images(uploaded, camera):
+    return camera if camera is not None else uploaded
+
+# ===== CSS for Theme Switching =====
+light_css = """
+<style>
+body { background-color: white; color: black; }
+.gr-button { background-color: #4CAF50; color: white; }
+.gr-input, .gr-textbox, .gr-dropdown, .gr-radio, .gr-markdown, .gr-container { background-color: white; color: black; }
+</style>
+"""
 
-    # Generate AI response
-    ai_response = generate_ai_response(disease_name, adjusted_confidence)
+dark_css = """
+<style>
+body { background-color: #121212 !important; color: #e0e0e0 !important; }
+.gr-button { background-color: #555 !important; color: white !important; }
+.gr-input, .gr-textbox, .gr-dropdown, .gr-radio, .gr-markdown, .gr-container { background-color: #333 !important; color: #e0e0e0 !important; }
+</style>
+"""
 
-    # Return results
-    result = f"{disease_name} (Confidence: {adjusted_confidence:.2f}%)"
-    raw_text = f"Raw Confidence: {raw_confidence:.2f}%"
-    return result, raw_text, ai_response
+def update_css(theme):
+    if theme == "Dark":
+        return dark_css
+    else:
+        return light_css
 
-# Simplified Gradio UI for better compatibility
+# ===== Gradio Interface =====
 with gr.Blocks() as demo:
-    gr.Markdown("# 🍅 EvSentry8: Tomato Disease Detection with AI Assistant")
-
-    with gr.Tab("Disease Detection"):
-        with gr.Row():
-            with gr.Column():
-                image_input = gr.Image(type="pil", label="Upload a Tomato Leaf Image", sources=["upload", "webcam", "clipboard"])
-
-                scaling_method = gr.Radio(
-                    ["Temperature Scaling", "Min-Max Normalization"],
-                    label="Confidence Scaling Method",
-                    value="Temperature Scaling"
-                )
-                temperature_slider = gr.Slider(0.5, 2.0, step=0.1, label="Temperature", value=1.0)
-                min_conf_slider = gr.Slider(0, 100, step=1, label="Min Confidence", value=20)
-                max_conf_slider = gr.Slider(0, 100, step=1, label="Max Confidence", value=90)
-
-                detect_button = gr.Button("Detect Disease")
-
-            with gr.Column():
-                disease_output = gr.Textbox(label="Detected Disease & Adjusted Confidence")
-                raw_confidence_output = gr.Textbox(label="Raw Confidence")
-                ai_response_output = gr.Markdown(label="AI Assistant's Analysis & Recommendations")
-
-    with gr.Tab("Chat with Expert"):
-        gr.Markdown("# 💬 Chat with Agricultural Expert")
-        gr.Markdown("Ask any questions about tomato farming, diseases, or agricultural practices.")
-
-        chatbot = gr.Chatbot(height=400)
-
-        with gr.Row():
-            chat_input = gr.Textbox(
-                label="Your Question",
-                placeholder="Ask about tomato farming, diseases, or agricultural practices...",
-                lines=2
+    # Hidden element for CSS injection (initially Light theme)
+    css_injector = gr.HTML(update_css("Light"))
+    
+    gr.Markdown("# 🌿 FarMVi8ioN – AI-powered Crop Monitoring")
+    gr.Markdown("Detect tomato leaf diseases and get actionable advice on how to curb them.")
+    
+    with gr.Row():
+        # ----- Left Column (≈30%) -----
+        with gr.Column(scale=1):
+            version = gr.Dropdown(
+                choices=["1.1", "1.2", "1.3", "2.1", "2.2", "2.3"],
+                label="Select Version",
+                value="1.3",
+                info="Versions 1.x use Model A; Versions 2.x use Model B."
             )
-            chat_button = gr.Button("Send")
-
-        gr.Markdown("""
-        ### Example Questions:
-        - How do I identify tomato bacterial spot?
-        - What's the best way to prevent late blight?
-        - How often should I water my tomato plants?
-        - What are the signs of nutrient deficiency in tomatoes?
-        """)
-
-    # Set up event handlers
-    detect_button.click(
-        detect_disease_scaled,
-        inputs=[image_input, scaling_method, temperature_slider, min_conf_slider, max_conf_slider],
-        outputs=[disease_output, raw_confidence_output, ai_response_output]
-    )
-
-    # Chat functionality
-    chat_button.click(
-        fn=chat_with_expert,
-        inputs=[chat_input, chatbot],
-        outputs=[chat_input, chatbot]
-    )
-
-    # Also allow pressing Enter to send chat
-    chat_input.submit(
-        fn=chat_with_expert,
-        inputs=[chat_input, chatbot],
-        outputs=[chat_input, chatbot]
+            
+            theme_choice = gr.Radio(
+                choices=["Light", "Dark"],
+                label="Select Theme",
+                value="Light"
+            )
+            
+            gr.Markdown("### Notebook Links")
+            gr.Markdown(
+                """
+                **For Model A:**
+                - Model A Only: [Training Notebook](https://colab.research.google.com/drive/1FMjs7JmdO6WVoXbzLA-ymwnIKq-GaV6w?usp=sharing)
+                - Model A & Classifier: [Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)
+                
+                **For Model B:**
+                - Model B Only: [Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)
+                - Model B & Classifier: [Training Notebook](https://colab.research.google.com/drive/1CvoQY40gK2YsMgt4wq9kM2ZSO2c4lzFU?usp=sharing)
+                """
+            )
+        
+        # ----- Right Column (≈70%) -----
+        with gr.Column(scale=2):
+            image_input = gr.Image(label="📂 Upload Tomato Leaf Image", type="pil", sources=["upload", "webcam", "clipboard"])
+            submit = gr.Button("🔍 Analyze", variant="primary")
+    
+    output = gr.Markdown(label="📝 Diagnosis & Advice")
+    
+    # Update CSS dynamically based on theme selection
+    theme_choice.change(fn=update_css, inputs=theme_choice, outputs=css_injector)
+    
+    # When submit is clicked, combine image inputs and process the selected version
+    submit.click(
+        fn=lambda img, ver: process_version(img, ver),
+        inputs=[image_input, version],
+        outputs=output
     )
 
 demo.launch()