Problem Being Solved

The plant-disease-predictor API gives you a programmatic way to detect diseases in plants by analyzing leaf images. This page explains the core problem the service addresses, why automated leaf analysis matters, and what value the API delivers to applications serving farmers and gardeners. Understanding this context will help you design effective integrations and set correct expectations for the API's behavior.

The Challenge: Identifying Plant Disease at Scale

Plant disease is one of the leading causes of crop loss worldwide. Traditional diagnosis relies on a trained agronomist physically inspecting plants — a process that is slow, expensive, and unavailable to most smallholder farmers and home gardeners. By the time visible symptoms are recognized and an expert is consulted, significant damage may already have occurred.

Your users face a concrete problem: they can see that something is wrong with a plant's leaves, but they cannot quickly identify what is wrong or what to do about it.

What This Service Provides

The plant-disease-predictor API solves this problem by exposing a trained convolutional neural network (CNN) model as a web service. When your application sends a leaf image to the API, the model analyzes the visual patterns in that image and returns a disease classification.

The underlying model is a CNN built with sequential Conv2D layers, trained on the PlantVillage dataset — a large, labeled collection of leaf images spanning 38 disease and health categories across multiple crop species, including:

• Tomato (e.g., Leaf Mold, healthy)
• Potato (e.g., Late Blight)
• Apple (e.g., Black Rot, Cedar Apple Rust)
• Cherry (e.g., healthy)
• Grape (e.g., healthy)
• And many more across the full 38-class label set

This breadth means the API can handle a wide variety of plant types and conditions your users are likely to encounter in the field or garden.

Why a CNN for This Problem?

Convolutional neural networks are particularly well-suited to image classification tasks because they learn spatial hierarchies of features — edges, textures, color patterns — directly from pixel data. For leaf disease detection, this means the model can distinguish subtle visual signatures (discoloration, lesion shape, spot distribution) that would be difficult to encode with hand-crafted rules.

The model was trained on color images at 256×256 pixels. When you send a leaf image through the API, it is preprocessed to match this format before inference, so you do not need to resize or normalize images yourself.

What the API Does Not Do

Understanding the boundaries of the service is equally important:

• The API classifies disease based on visual leaf appearance only. It does not provide treatment recommendations, pest identification, or soil analysis.
• Predictions reflect the confidence of the model against the 38 trained classes. Images of plants outside the training distribution (uncommon species, extreme lighting, non-leaf subjects) may produce unreliable results.
• The service is not a substitute for expert agronomic advice in high-stakes production environments.

Intended Integration Pattern

The primary workflow you will implement against this API is:

1. Capture a leaf image from your user (via camera, file upload, or URL).
2. Submit the image to the prediction endpoint.
3. Receive a structured response containing the predicted disease class and confidence score.
4. Display the result to your user with appropriate context.

This pattern is deliberately simple so you can embed disease detection into mobile apps, farm-management dashboards, or IoT edge devices with minimal integration effort.

Example: Understanding a Prediction Response

The following illustrates the kind of result you can expect after submitting a leaf image to the API. This is not a live call — it shows the response structure so you can plan your parsing logic.

Scenario: A user photographs a tomato leaf with visible mold and uploads it through your application.

// POST /predict
// Request: multipart/form-data with field "image" containing the leaf photo

// Example response body (HTTP 200 OK)
{
  "prediction": "Tomato___Leaf_Mold",
  "confidence": 0.94,
  "status": "success"
}

What this tells you:

• prediction: The model's top classification label, using the PlantName___ConditionName naming convention drawn from the PlantVillage dataset.
• confidence: A float between 0 and 1 representing the model's certainty. A value of 0.94 indicates high confidence.
• status: Confirms the request was processed successfully.

Example: Healthy Plant Result

// POST /predict
// Request: multipart/form-data with field "image" containing a healthy apple leaf

// Example response body (HTTP 200 OK)
{
  "prediction": "Apple___healthy",
  "confidence": 0.88,
  "status": "success"
}

Note: When a plant is healthy, the prediction field returns the PlantName___healthy label. You should handle this case explicitly in your UI so users receive a positive confirmation rather than silence.

• API Endpoints Reference — Details on every available route, HTTP methods, and URL parameters.
• Request and Response Formats — Full schema definitions for image upload requests and prediction response payloads, including all field types and constraints.
• Authentication — How to obtain and use API credentials to authorize requests.
• Error Handling — A catalog of error codes and messages the API returns, and how to handle them gracefully in your integration.
• Interpreting Prediction Results — Guidance on working with confidence scores, the 38-class label taxonomy, and presenting results to end users.
• Quickstart: Upload a Leaf Image — A step-by-step walkthrough covering install, launch, and your first successful prediction call.