Add application file

.gitignore

@@ -0,0 +1,2 @@
+.env
+assets

app.py

@@ -0,0 +1,115 @@
+import os
+import json
+import numpy as np
+import gradio as gr
+from PIL import Image
+from model_loader import load_model, preprocess_image, predict_disease
+from chat_app import groq_chatbot
+
+# Load the disease diagnosis model
+model_path = "attached_assets/mobilenetv2.h5"
+model = load_model(model_path)
+
+# Load class labels
+with open("class_labels.json", "r") as f:
+    class_labels = json.load(f)
+
+# Disease treatments dictionary
+DEMO_TREATMENTS = {
+    "Apple - Apple Scab": "Rake and destroy fallen leaves, prune for good air circulation, apply fungicides like captan or sulfur before rainy periods, and plant resistant apple varieties.",
+    "Apple - Black Rot": "Prune and remove infected branches, destroy fallen leaves and fruit, apply copper-based fungicides, and ensure proper spacing between trees.",
+    "Apple - Cedar Apple Rust": "Remove nearby juniper or cedar trees if possible, apply fungicides like myclobutanil, and plant resistant apple varieties.",
+    "Apple - Healthy": "Your apple tree appears healthy! Continue regular maintenance, including pruning, watering, and monitoring for pests or disease symptoms.",
+    "Background without Leaves": "No plants detected. Please upload an image containing leaves to diagnose.",
+    "Blueberry - Healthy": "Your blueberry plant is healthy! Ensure consistent watering, proper mulching, and protect it from frost during early spring.",
+    "Cherry - Powdery Mildew": "Remove infected leaves, avoid overhead watering, ensure good air circulation, and apply fungicides containing sulfur or potassium bicarbonate.",
+    "Cherry - Healthy": "Your cherry tree is healthy! Continue providing proper care, including regular pruning, watering, and monitoring for pests or diseases.",
+    "Corn - Cercospora Leaf Spot (Gray Leaf Spot)": "Rotate crops annually, apply fungicides like strobilurins or triazoles, and ensure good field drainage and proper plant spacing.",
+    "Corn - Common Rust": "Apply fungicides containing propiconazole or azoxystrobin, plant resistant corn varieties, and avoid overhead irrigation.",
+    "Corn - Northern Leaf Blight": "Rotate crops, plant resistant varieties, and apply fungicides like mancozeb or strobilurin when symptoms first appear.",
+    "Corn - Healthy": "Your corn plant looks healthy! Continue to monitor for any signs of disease and ensure proper spacing for airflow.",
+    "Grape - Black Rot": "Remove mummified berries and infected leaves, prune for good air circulation, and apply fungicides such as myclobutanil or captan.",
+    "Grape - Esca (Black Measles)": "Prune and destroy infected parts, practice proper vineyard sanitation, and avoid mechanical injuries to the vines.",
+    "Grape - Leaf Blight (Isariopsis Leaf Spot)": "Remove and destroy infected leaves, apply fungicides containing copper, and ensure proper spacing for air circulation.",
+    "Grape - Healthy": "Your grapevine is healthy! Maintain regular pruning, proper watering, and monitoring for pests or diseases.",
+    "Orange - Huanglongbing (Citrus Greening)": "Unfortunately, there is no cure. Remove and destroy infected trees, control psyllid populations using insecticides, and plant disease-free certified saplings.",
+    "Peach - Bacterial Spot": "Apply copper-based bactericides, remove and destroy infected leaves and fruit, and plant resistant peach varieties.",
+    "Peach - Healthy": "Your peach tree looks healthy! Continue regular care, including pruning, fertilizing, and monitoring for pests or diseases.",
+    "Pepper (Bell) - Bacterial Spot": "Apply fixed copper sprays, avoid overhead irrigation, remove infected plants, and practice crop rotation.",
+    "Pepper (Bell) - Healthy": "Your bell pepper plant looks healthy! Ensure adequate sunlight, watering, and keep monitoring for any pests or diseases.",
+    "Potato - Early Blight": "Remove infected leaves, apply fungicides with active ingredients like chlorothalonil, and ensure proper spacing between plants.",
+    "Potato - Late Blight": "Apply fungicides like mancozeb or chlorothalonil, remove and destroy infected plants, and avoid overhead watering.",
+    "Potato - Healthy": "Your potato plant looks healthy! Maintain proper watering, ensure good soil drainage, and monitor for any signs of disease.",
+    "Raspberry - Healthy": "Your raspberry plant is healthy! Ensure proper support, regular pruning, and protect it from pests and harsh weather conditions.",
+    "Soybean - Healthy": "Your soybean crop is healthy! Monitor regularly for any signs of disease or pests, and maintain proper crop rotation.",
+    "Squash - Powdery Mildew": "Apply fungicides with sulfur or potassium bicarbonate, remove infected leaves, and ensure good air circulation.",
+    "Strawberry - Leaf Scorch": "Remove infected leaves, avoid overhead watering, and apply fungicides like captan or mancozeb.",
+    "Strawberry - Healthy": "Your strawberry plants are healthy! Maintain consistent watering, ensure good air circulation, and protect from frost.",
+    "Tomato - Bacterial Spot": "Remove infected leaves, apply fixed copper sprays, and avoid overhead irrigation. Ensure proper plant spacing.",
+    "Tomato - Early Blight": "Remove infected leaves, apply fungicides containing chlorothalonil or copper, and mulch around plants to prevent soil splashing.",
+    "Tomato - Late Blight": "Apply fungicides like chlorothalonil or mancozeb, remove infected plants, and ensure proper spacing for airflow.",
+    "Tomato - Leaf Mold": "Remove infected leaves, ensure proper air circulation, and apply fungicides containing chlorothalonil or copper.",
+    "Tomato - Septoria Leaf Spot": "Remove and destroy infected leaves, apply fungicides like mancozeb, and avoid overhead watering.",
+    "Tomato - Spider Mites (Two-Spotted Spider Mite)": "Spray the undersides of leaves with water, apply horticultural oils or insecticidal soaps, and maintain humidity around plants.",
+    "Tomato - Target Spot": "Remove infected leaves, apply fungicides like chlorothalonil, and ensure proper spacing between plants for air circulation.",
+    "Tomato - Tomato Yellow Leaf Curl Virus": "Remove infected plants, control whitefly populations with insecticides, and plant resistant tomato varieties.",
+    "Tomato - Tomato Mosaic Virus": "Remove infected plants, sterilize tools, and avoid handling plants when wet.",
+    "Tomato - Healthy": "Your tomato plant is healthy! Maintain regular watering, ensure adequate sunlight, and monitor for pests or diseases."
+}
+
+# Diagnosis function
+def diagnose_image(image):
+    if image is None:
+        return "⚠️ Please upload an image for diagnosis."
+    
+    try:
+        img_array = np.array(image)
+        preprocessed_img = preprocess_image(img_array)
+        disease_label, confidence = predict_disease(model, preprocessed_img, class_labels)
+        confidence_pct = f"{confidence:.1f}%"
+        
+        treatment = DEMO_TREATMENTS.get(
+            disease_label, 
+            "No specific treatment information available for this condition. Consult with an agricultural expert."
+        )
+        
+        result = f"### 🌿 Diagnosis: {disease_label.replace('_', ' ')}\n"
+        result += f"**Confidence:** {confidence_pct}\n\n"
+        result += f"### 🛠 Recommended Treatment:\n{treatment}"
+        return result
+    except Exception as e:
+        return f"❌ Error during diagnosis: {e}"
+
+# Build Gradio UI
+with gr.Blocks(css="footer {visibility: hidden}") as app:
+    gr.Markdown("# 🌱 Plant Disease Diagnosis & Agricultural Chatbot")
+    gr.Markdown("Upload an image of a plant leaf for disease detection, or ask the chatbot for agricultural advice.")
+
+    with gr.Row():
+        # LEFT: Image Upload & Disease Diagnosis
+        with gr.Column(scale=1):
+            gr.Markdown("## 📸 Upload Image for Diagnosis")
+            image_input = gr.Image(type="numpy", label="Upload Leaf Image")
+            diagnose_button = gr.Button("🔍 Diagnose", variant="primary")
+            diagnosis_output = gr.Markdown(label="Diagnosis Results")
+
+            diagnose_button.click(fn=diagnose_image, inputs=[image_input], outputs=[diagnosis_output])
+
+        # RIGHT: Chatbot for Agricultural Advice
+        with gr.Column(scale=1):
+            gr.Markdown("## 🤖 Ask the Agricultural Chatbot")
+            chatbot = gr.Chatbot(height=400)
+            msg = gr.Textbox(placeholder="Ask a question about agriculture...", label="Your Question")
+            clear = gr.Button("🗑 Clear Chat")
+            chat_history_state = gr.State([])
+
+            msg.submit(fn=groq_chatbot, inputs=[msg, chat_history_state], outputs=[chatbot, msg])
+            clear.click(lambda: ([], ""), None, [chatbot, msg], queue=False)
+
+    gr.Markdown("---")
+    gr.Markdown("### ℹ️ About this Application")
+    gr.Markdown("This AI-powered tool helps diagnose plant diseases and provides treatment recommendations. It also includes a chatbot for general agricultural queries.")
+
+# Launch Gradio app
+if __name__ == "__main__":
+    app.launch(share=True)

chat_app.py

@@ -0,0 +1,82 @@
+import os
+from groq import Groq
+import gradio as gr
+from dotenv import load_dotenv
+load_dotenv()
+# Load API key from environment variable
+API_KEY = os.getenv("GROQ_API_KEY")
+if not API_KEY:
+    raise ValueError("Missing GROQ_API_KEY environment variable. Set it in Hugging Face Spaces Secrets.")
+
+client = Groq(api_key=API_KEY)
+
+VALIDATION_PROMPT = "You are an intelligent assistant. Analyze the input question carefully. Respond with 'Yes' if the input is agriculture-related, and 'No' otherwise."
+RESPONSE_PROMPT = "You are an agriculture expert. Provide a concise and accurate answer to the following agriculture-related question:"
+
+def validate_input(input_text):
+    try:
+        validation_response = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": VALIDATION_PROMPT},
+                {"role": "user", "content": input_text},
+            ],
+            temperature=0,
+            max_completion_tokens=1,
+        )
+        return validation_response.choices[0].message.content.strip()
+    except Exception as e:
+        return f"Error: {e}"
+
+def get_agriculture_response(input_text):
+    try:
+        detailed_response = client.chat.completions.create(
+            model="llama-3.1-8b-instant",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": RESPONSE_PROMPT},
+                {"role": "user", "content": input_text},
+            ],
+            temperature=0.5,
+            max_completion_tokens=700,
+        )
+        return detailed_response.choices[0].message.content.strip()
+    except Exception as e:
+        return f"Error: {e}"
+
+def groq_chatbot(input_text, chat_history):
+    validation_result = validate_input(input_text)
+    
+    if validation_result.lower() == "yes":
+        response = get_agriculture_response(input_text)
+    elif validation_result.lower() == "no":
+        response = "❌ This is not an agriculture-related question."
+    else:
+        response = f"⚠️ Unexpected response: {validation_result}"
+
+    # Append to chat history
+    chat_history.append((input_text, response))
+    return chat_history, ""  # Clears input field after submission
+
+def launch_gradio_interface():
+    with gr.Blocks() as demo:
+        gr.Markdown("### 🌱 Agriculture AI Assistant")
+        gr.Markdown("Ask questions about plant diseases, treatments, or general agricultural topics.")
+
+        chatbot = gr.Chatbot(height=400)
+        msg = gr.Textbox(placeholder="Ask a question about agriculture...", label="Your Question")
+        clear = gr.Button("Clear Chat")
+
+        chat_history_state = gr.State([])  # Stores chat history
+
+        # ✅ Enter key submits the question
+        msg.submit(fn=groq_chatbot, inputs=[msg, chat_history_state], outputs=[chatbot, msg])
+
+        # ✅ Clicking "Clear Chat" resets history
+        clear.click(lambda: ([], ""), None, [chatbot, msg], queue=False)
+
+    demo.launch(share=True)
+
+if __name__ == "__main__":
+    launch_gradio_interface()

class_labels.json

@@ -0,0 +1,41 @@
+{
+    "0": "Apple - Apple Scab",
+    "1": "Apple - Black Rot",
+    "2": "Apple - Cedar Apple Rust",
+    "3": "Apple - Healthy",
+    "4": "Background without Leaves",
+    "5": "Blueberry - Healthy",
+    "6": "Cherry - Powdery Mildew",
+    "7": "Cherry - Healthy",
+    "8": "Corn - Cercospora Leaf Spot (Gray Leaf Spot)",
+    "9": "Corn - Common Rust",
+    "10": "Corn - Northern Leaf Blight",
+    "11": "Corn - Healthy",
+    "12": "Grape - Black Rot",
+    "13": "Grape - Esca (Black Measles)",
+    "14": "Grape - Leaf Blight (Isariopsis Leaf Spot)",
+    "15": "Grape - Healthy",
+    "16": "Orange - Huanglongbing (Citrus Greening)",
+    "17": "Peach - Bacterial Spot",
+    "18": "Peach - Healthy",
+    "19": "Pepper (Bell) - Bacterial Spot",
+    "20": "Pepper (Bell) - Healthy",
+    "21": "Potato - Early Blight",
+    "22": "Potato - Late Blight",
+    "23": "Potato - Healthy",
+    "24": "Raspberry - Healthy",
+    "25": "Soybean - Healthy",
+    "26": "Squash - Powdery Mildew",
+    "27": "Strawberry - Leaf Scorch",
+    "28": "Strawberry - Healthy",
+    "29": "Tomato - Bacterial Spot",
+    "30": "Tomato - Early Blight",
+    "31": "Tomato - Late Blight",
+    "32": "Tomato - Leaf Mold",
+    "33": "Tomato - Septoria Leaf Spot",
+    "34": "Tomato - Spider Mites (Two-Spotted Spider Mite)",
+    "35": "Tomato - Target Spot",
+    "36": "Tomato - Tomato Yellow Leaf Curl Virus",
+    "37": "Tomato - Tomato Mosaic Virus",
+    "38": "Tomato - Healthy"
+}

model_loader.py

@@ -0,0 +1,88 @@
+import os
+import tensorflow as tf
+import numpy as np
+import cv2
+import logging
+
+# Setup logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+def load_model(model_path):
+    """
+    Load the MobileNetV2 model from the specified path
+    
+    Args:
+        model_path: Path to the .h5 model file
+        
+    Returns:
+        Loaded TensorFlow model
+    """
+    try:
+        logger.info(f"Loading model from {model_path}")
+        model = tf.keras.models.load_model(model_path)
+        logger.info("Model loaded successfully")
+        return model
+    except Exception as e:
+        logger.error(f"Error loading model: {str(e)}")
+        raise
+
+def preprocess_image(image, target_size=(224, 224)):
+    """
+    Preprocess the image for model input
+    
+    Args:
+        image: Input image (numpy array from OpenCV)
+        target_size: Target size for model input (default: 224x224)
+        
+    Returns:
+        Preprocessed image ready for model input
+    """
+    try:
+        # Convert BGR to RGB if from OpenCV
+        if len(image.shape) == 3 and image.shape[2] == 3:
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+        
+        # Resize image
+        image_resized = cv2.resize(image, target_size)
+        
+        # Convert to float and normalize
+        image_normalized = image_resized.astype(np.float32) / 255.0
+        
+        # Expand dimensions to create batch
+        image_batch = np.expand_dims(image_normalized, axis=0)
+        
+        return image_batch
+    except Exception as e:
+        logger.error(f"Error preprocessing image: {str(e)}")
+        raise
+
+def predict_disease(model, preprocessed_image, class_labels):
+    """
+    Predict disease from preprocessed image
+    
+    Args:
+        model: Loaded TensorFlow model
+        preprocessed_image: Preprocessed image batch
+        class_labels: Dictionary mapping class indices to labels
+        
+    Returns:
+        Tuple of (predicted disease label, confidence percentage)
+    """
+    try:
+        # Make prediction
+        predictions = model.predict(preprocessed_image)
+        
+        # Get the predicted class index
+        predicted_class_idx = np.argmax(predictions[0])
+        
+        # Get confidence score
+        confidence = float(predictions[0][predicted_class_idx] * 100)
+        
+        # Convert to label
+        label = class_labels.get(str(predicted_class_idx), f"Unknown class {predicted_class_idx}")
+        
+        return label, confidence
+    except Exception as e:
+        logger.error(f"Error making prediction: {str(e)}")
+        raise

requirements.txt

@@ -0,0 +1,9 @@
+tensorflow==2.15.0
+numpy>=1.22.0
+pillow>=10.0.0
+gradio>=4.0.0
+groq
+opencv-python
+opencv-python-headless
+bing_image_downloader
+python-dotenv

style.css

@@ -0,0 +1,32 @@
+body {
+    font-family: 'Arial', sans-serif;
+    background-color: #1e1e1e;
+    color: white;
+}
+
+#title {
+    margin-bottom: 20px;
+}
+
+#input-box textarea {
+    background-color: #2c2c2c !important;
+    color: white;
+    border-radius: 10px;
+    font-size: 16px;
+}
+
+#validate-button {
+    background-color: #4CAF50 !important;
+    color: white;
+    font-size: 18px;
+    border-radius: 8px;
+    padding: 10px 15px;
+}
+
+#validation-result, #output-box {
+    background-color: #2c2c2c !important;
+    color: white;
+    font-size: 16px;
+    border-radius: 8px;
+    padding: 10px;
+}

utils.py

@@ -0,0 +1,88 @@
+import re
+import logging
+from difflib import get_close_matches
+
+# Setup logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+def extract_disease_name(prediction):
+    """
+    Extract just the disease name from a prediction that might include plant name
+    
+    Args:
+        prediction: Full prediction string (e.g., "Tomato_Late_blight")
+        
+    Returns:
+        Extracted disease name
+    """
+    try:
+        # Handle common formats like "Plant_Disease" or "Plant Disease"
+        if '_' in prediction:
+            parts = prediction.split('_')
+        else:
+            parts = prediction.split(' ')
+        
+        if len(parts) <= 1:
+            return prediction  # Return as is if can't split
+        
+        # Skip the plant name (first part) and join the rest
+        disease_parts = parts[1:]
+        disease_name = ' '.join(disease_parts)
+        
+        # Clean up the disease name
+        disease_name = disease_name.replace('_', ' ').strip()
+        
+        return disease_name
+    except Exception as e:
+        logger.error(f"Error extracting disease name: {str(e)}")
+        return prediction  # Return original on error
+
+def normalize_disease_name(disease_name):
+    """
+    Normalize disease names for better matching
+    
+    Args:
+        disease_name: Disease name to normalize
+        
+    Returns:
+        Normalized disease name
+    """
+    # Convert to lowercase
+    normalized = disease_name.lower()
+    
+    # Remove special characters
+    normalized = re.sub(r'[^a-z0-9\s]', '', normalized)
+    
+    # Replace multiple spaces with single space
+    normalized = re.sub(r'\s+', ' ', normalized).strip()
+    
+    return normalized
+
+def find_similar_disease(disease_name, known_diseases):
+    """
+    Find the most similar disease name in a list of known diseases
+    
+    Args:
+        disease_name: Query disease name
+        known_diseases: List of known disease names
+        
+    Returns:
+        Most similar disease name, or the original if no good match
+    """
+    # Normalize the query
+    norm_query = normalize_disease_name(disease_name)
+    
+    # Normalize all known diseases
+    norm_known = [normalize_disease_name(d) for d in known_diseases]
+    
+    # Find close matches
+    matches = get_close_matches(norm_query, norm_known, n=1, cutoff=0.6)
+    
+    if matches:
+        # Get the index of the match in the normalized list
+        match_idx = norm_known.index(matches[0])
+        # Return the original form of the matched disease
+        return known_diseases[match_idx]
+    
+    return disease_name  # Return original if no good matches