https://github.com/shaheennabi/production-ready-leaflogic-multi-ai-agents-project

🍃🌱 Business or Production ready automated one-click. An AI-driven system designed to identify 100+ plants and crops while providing enriched details sourced from the web by using Multi-AI Agents. Ideal for industry use, this scalable project showcases power of object detection & Multi-AI Agents tech for real-world applications. 🍃🌍 🚀�
https://github.com/shaheennabi/production-ready-leaflogic-multi-ai-agents-project

amazon-web-services api cloud computer-vision deployed information-retrieval internship-project leaflogic modular-code plant-recognition production-ready pytorch scalable tensorflow web-scraping

Last synced: 6 months ago
JSON representation

🍃🌱 Business or Production ready automated one-click. An AI-driven system designed to identify 100+ plants and crops while providing enriched details sourced from the web by using Multi-AI Agents. Ideal for industry use, this scalable project showcases power of object detection & Multi-AI Agents tech for real-world applications. 🍃🌍 🚀�

• Host: GitHub
• URL: https://github.com/shaheennabi/production-ready-leaflogic-multi-ai-agents-project
• Owner: shaheennabi
• License: mit
• Created: 2024-11-17T17:51:06.000Z (11 months ago)
• Default Branch: main
• Last Pushed: 2025-03-02T17:13:21.000Z (7 months ago)
• Last Synced: 2025-03-28T05:31:43.839Z (6 months ago)
• Topics: amazon-web-services, api, cloud, computer-vision, deployed, information-retrieval, internship-project, leaflogic, modular-code, plant-recognition, production-ready, pytorch, scalable, tensorflow, web-scraping
• Language: Jupyter Notebook
• Homepage:
• Size: 14.2 MB
• Stars: 5
• Watchers: 1
• Forks: 2
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • Funding: .github/FUNDING.yml
  • License: LICENSE

Awesome Lists containing this project

README

          
# 🌿 Production-Ready-LeafLogic-Multi-AI-Agents-Project  🌱  

*visitors: please wait for few seconds till readme loads (actually it's image heavy).*

# Problem Statement

## 🌱 Building an Automated Plant and Crop Recognition System 🌿

We were tasked with developing a powerful AI-driven system that could recognize up to 100 different types of plants and crops while fetching complete details about them from the internet. The goal was to enable users to identify plants and obtain reliable information effortlessly, reducing the chances of misleading sales practices in the plant market.

### To achieve this, we leveraged a combination of:

- **Object Detection Models**: To accurately recognize various plant and crop species.

- **Multi-AI Agent Pipeline**: Handling detailed research on the detected plant/crop, covering scientific details, historical significance, health benefits, seasonal information, market price, and more.

- **OpenAI Model & UI Integration**: Generates a summary that is sent to the user via email.

## 🌿 Our Role as Developers 🌱

As a team of three contributors, our mission is to build a high-quality, scalable system that:

- Accurately detects a wide range of plants and crops.

- Automates the research process using multi-AI agents to gather real and accurate information from the internet.

- Ensures modular architecture for future scalability and easy maintenance.

- Provides users with trustworthy, well-structured insights on each recognized plant/crop.

- Maintains cost efficiency while delivering high performance and reliability.

This system is designed to deliver seamless plant identification and detailed research findings, ensuring that users have access to verified and comprehensive information. By integrating advanced Object Detection and AI Agents, we aim to create a reliable solution that empowers users with knowledge and prevents misinformation in the market.

## 🎯 Project Goals

### Deliver a System to Meet Client Needs

- Create a system to provide accurate and instant plant/crop insights, ensuring users receive reliable information.

### Build a Modular Architecture

- Design the system to support scalability and future upgrades, making modifications seamless.

### Testing and Quality Assurance

- Ensure the system’s reliability and accuracy through rigorous testing.

### Cost-Effective Measures

- Optimize API and model-related costs without compromising performance.

---

## ✨💚 Our Approach

The project followed a structured approach to ensure efficient execution and high-quality results.

### Steps in Our Approach

#### Framework Selection

- Chose **Object Detection with YOLOv5**, trained on an **A100 GPU** with a **self-annotated dataset** of **25K images**, which we later **open-sourced** for the community.

- For our AI Agents pipeline, we used taskflowai framework to build these (as it's high-quality open-source support framework-used to build Multi_AI Agent system).

#### Model Selection

- **OpenAI GPT-3.5 Turbo** was chosen for:

  - **Tool-Calling Excellence**: Best ability to call tools and manage multi-agent tasks seamlessly.

  - **Token Management**: Optimized context handling and reasoning.

  - **Report Generation**: Efficiently processing and generating structured reports.

- **LLaMA & Google Models** were tested but failed in reasoning, token management, and memory performance.

- **OpenAI o1 Series Models** offered strong performance but were too expensive for this project.

- **Groq Inference Engine** was also tested but did not meet the project’s performance indicators.

#### System Design and Development

- Built a **modular architecture**, ensuring future adaptability and easy upgrades.

#### Cost Optimization

- Minimized API costs by **choosing GPT-3.5 Turbo** and optimizing system performance.

#### Testing and Delivery

- Conducted rigorous testing to validate accuracy and reliability (in containers etc).

- Delivered the project on time, exceeding quality expectations.

---

## 🚧 Challenges Encountered

### 1. Model & API Cost

- Running inference and AI agents on cloud infrastructure was **cost-intensive**, requiring optimizations.

### 2. Training on a Large Dataset

- **Training on 25K images** with **A100 GPU** required substantial resources and time.

### 3. Cloud Inference Costs

- Running the **entire pipeline on the cloud** every time a user pings the system was expensive.

### 4. Data Annotation Process

- Annotation of **25K images** was a **time-consuming** and **labor-intensive** task, requiring collaboration among contributors.

## 🌟 How We Fixed Challenges  

#### Solutions Implemented

- **Choosing GPT-3.5 Turbo**: A cost-effective alternative while maintaining performance.  

- **Optimizing Training**: Trained the model on **100 epochs** with **25K images**, which was computationally intensive but proved effective.  

- **Cloud Cost Optimization**: Leveraged **EC2 instances** to fetch the **Docker image** from **ECR**, reducing overall cloud costs.  

- **Efficient Data Annotation**: Two contributors collaboratively annotated the dataset, significantly reducing annotation time and effort.  

---

## 🌿 System Design or Project Pipeline  

To simplify the complexity of our pipeline, we divide it into two main components:  

1. **Training Pipeline**  

2. **Prediction Pipeline + AI Agents**  

### 🔧 Training Pipeline

*This is how **Training Pipeline** looks like*  

![training  pipeline](https://github.com/user-attachments/assets/6e70008f-ae61-4c3c-8d01-ba92485c2c14)

First, we will retrieve data from **S3** as part of the **Data Ingestion Process** using this script from `utils`.  



- The `download_file` method:

  - Retrieves the file size using `head_object` for accurate progress tracking.

  - Uses `TransferConfig` to enable efficient multipart downloads (5MB chunks).

  - Implements a **progress callback** (`ProgressPercentage`) to log real-time updates.

  - Logs the start and completion of the download process for better visibility.

  - Handles errors gracefully by raising a `CustomException` on failure.

- The `run()` method acts as an entry point to execute the download seamlessly

###  Data Ingestion

After downloading the dataset from **S3** as `leaflogic_dataset.zip`, it is stored in the **data_ingestion_dir**. The script then extracts the dataset into the **feature_store_path**, ensuring the data is properly organized for further processing.

*This is the shot of only `initiate_data_ingestion` for more go to `src/leaflogic/components/data_ingestion.py`



- **Initialization (`__init__` Method)**:  

  - Sets up the data ingestion directory.  

  - Logs initialization status.  

- **Data Download (`download_data` Method)**:  

  - Downloads the dataset from **S3** and saves it as `leaflogic_dataset.zip`.  

  - Uses **S3FileDownloader** to fetch the file.  

- **Data Extraction (`extract_zip_file` Method)**:  

  - Extracts `leaflogic_dataset.zip` into a temporary directory.  

  - Moves only the relevant dataset (`leaflogic_dataset`) into the **feature_store_path**.  

  - Cleans up temporary files after extraction.  

- **Data Ingestion Pipeline (`initiate_data_ingestion` Method)**:  

  - Calls the download and extraction methods in sequence.  

  - Returns a **DataIngestionArtifact**, storing paths to the downloaded and extracted dataset.  

  - Ensures proper logging and exception handling to track failures efficiently.  

### Prepare  BaseModel

After **data ingestion**, we prepare the base model by configuring `yolov5s.yaml` into `custom_yolov5s.yaml`. This involves updating the **number of categories (nc)** from `data.yaml` and defining essential parameters such as the **backbone, head, and other configurations** for training.

*This is the shot of only `prepare_basemodel` for more go to `src/leaflogic/components/prepare_base_model.py`



- **Initialization (`__init__` Method)**:  

  - Loads the data ingestion artifacts.  

  - Locates `data.yaml` to retrieve the number of classes (`nc`).  

  - Ensures the file exists before proceeding.  

- **Updating Model Configuration (`update_model_config` Method)**:  

  - Reads `data.yaml` to extract the number of categories.  

  - Loads the base YOLOv5 model config (`yolov5s.yaml`).  

  - Updates the `nc` field along with other essential configurations.  

  - Saves the modified configuration as `custom_yolov5s.yaml`,  

    but for **preserving the original structure**, we have written a custom `write_yaml_file` function in `utils`.  

    When modifying the `nc` parameter, the default YAML formatting would break, so this function ensures the correct structure is maintained.

  

*these are the shots of `write_yaml_file` for maintaining structure from `utils`  







*back to `prepare_basemodel`*

- **Model Preparation (`prepare_model` Method)**:  

  - Calls `update_model_config()` to generate the custom YOLOv5 config.  

  - Returns an artifact containing the path to the updated configuration file.  

  - Ensures all changes are logged for tracking and debugging. 

###  Model Trainer

After preparing the base model, we proceed to **training**. This stage utilizes the `data_ingestion` and `prepare_base_model` artifacts to train the model effectively.

  

*These are the shots of only `initiate_model_trainer` for more go to `src/leaflogic/components/model_training.py`





During this stage:

- We **relocate** dataset files (`train`, `valid`, `test`, `data.yaml`) to the root directory to simplify file path management during training.  

- We **initiate the training** process using YOLOv5, specifying the dataset, model architecture, training parameters, and hardware configurations.  

- After training, we **move the best-trained model (`best.pt`)** to the root directory for easier access.  

- Finally, we **clean up unnecessary files** from the root directory to maintain a structured workspace. 

 *code overview* 

 

- **Initialization (`__init__` Method)**:  

  - Loads the **data ingestion** and **base model preparation** artifacts.  

  - Retrieves essential file paths such as `data.yaml`, the updated model config, and the model trainer directory.  

  - Ensures that `data.yaml` and the model config exist before proceeding.  

- **Moving Data for Training (`move_data_files_to_root` Method)**:  

  - Moves `data.yaml`, `train`, `valid`, and `test` directories from `feature_store_path` to the root directory.  

  - This ensures compatibility with the training script.  

- **Model Training (`initiate_model_trainer` Method)**:  

  - Moves data files to the root directory for ease of training.  

  - Runs the **YOLOv5 training script** with the correct configurations.  

  - Saves the **best model (`best.pt`)** to the root directory for easier access.  

  - Deletes unnecessary files (`data.yaml`, `train`, `valid`, `test`) after training is complete.  

- **Post-Training Cleanup (`delete_data_files_from_root` Method)**:  

  - Removes `data.yaml`, `train`, `valid`, and `test` directories from the root after training.  

  - Ensures a clean working environment.  

### ** and here the *training pipeline* ends **

---

### 🔍 Prediction Pipeline + AI Agents  

Now that we have successfully trained our model, let's move on to the **prediction pipeline** and **AI agents**. This phase involves using the trained model to detect objects in images and leveraging AI agents to fetch relevant insights about the detected crops/plants.  

### ** now let's talk about our Prediction Pipeline + AI Agents**

*This is how **Prediction Pipeline + AI Agents** looks like* 

![CI_CD Diagram (1)](https://github.com/user-attachments/assets/753c187e-e67f-4162-a4c3-e1a959a69113)

first let me take you to the tour of `app.py` that is present in `root directory` that orchestrates the object detection and AI research pipeline. It first defines necessary paths and functions to handle detection, processing, and research execution.

#### 1. Defining Paths and Functions  

Before executing the pipeline, the script defines essential paths and utility functions to manage object detection and research processing.

#### 2. Fetching the Latest Experiment Folder  

The function `get_latest_exp_folder()` retrieves the most recent experiment folder stored in `yolov5/runs/detect`. This ensures that the latest detection results are used in the pipeline.

#### 3. Running Object Detection  

To perform object detection, the script executes `run_yolo_detection()`, which utilizes the `os.system` command to run the YOLO model. The detected results are stored inside `detected_objects.txt`.

#### 4. Processing Predictions  

The detected indices are mapped to category labels using `process_prediction()`. This function relies on `get_label_by_idex` from `utils`, which compares each detected index with the categories defined in `data.yaml`.

#### 5. Reading Detected Objects  

The function `read_detected_objects()` reads the detected object labels from `detected_objects.txt`. These labels are then passed to AI agents for further analysis.

#### 6. Executing AI Research  

To gather insights on detected objects, `execute_research_and_report()` is invoked. This function triggers multiple research tasks:  

   - `research_overall_web` – General web research  

   - `research_health` – Health-related information  

   - `research_season` – Seasonal relevance  

   - `research_price` – Market price analysis  

#### 7. Saving and Summarizing Results  

The research findings are stored in `research_results`, and the `generate_summaried_report()` function compiles a final summarized report.

This structured approach ensures an efficient pipeline, from object detection to AI-powered analysis and reporting.

*almost every function in `app.py` is invoked by `/predict` route*, after all of it the report is sent to email -> user provides. 

### **Now, let's talk about each portion step-by-step**

You can explore `app.py` to see how functions like `get_latest_exp_folder()`, `run_yolo_detection()`, `process_prediction()`, and `read_detected_objects()` work. Additionally, also look at how `execute_research_and_report()` sequentially executes tasks and how `generate_summaried_report()` compiles the final report.  (not too difficult)

Since the README will become extensive, we'll focus on the key components and their underlying structure, such as:  **`research_overall_web`**, **`research_health`**, **`research_season`**, **`research_price`**.

### research_overall_web task



1. **Agent Initialization**  

   - It initializes the `WebResearchAgent` using `WebResearchAgent.initialize_web_research_agent()`.  

   - This agent is designed to search the web and gather relevant information efficiently.  

2. **Task Creation**  

   - A `Task` object is created using `Task.create()`, where:  

     - The **agent** is assigned to perform the task.  

     - The **context** includes the plant’s name for reference.  

     - The **instruction** specifies details to be researched, such as:  

       - Scientific classification, origin, and regions.  

       - Uses, benefits, and growth conditions.  

       - Common pests, diseases, and economic significance.  

       - Fetching **relevant images** related to the plant.  

### research_health task



1. **Agent Initialization**  

   - The function initializes the `WebResearchAgent` using `WebResearchAgent.initialize_web_research_agent()`.  

   - This agent searches the web for reliable health-related information.  

2. **Task Creation**  

   - A `Task` object is created using `Task.create()`, where:  

     - The **agent** is assigned to perform the task.  

     - The **context** includes the plant’s name for better focus.  

     - The **instruction** outlines key health aspects to research:  

       - **Medicinal benefits** and traditional uses.  

       - **Potential risks** and toxicity concerns.  

       - **Nutritional value** and components.  

       - **Traditional remedies** where applicable.  

     - The gathered insights should be structured and referenced properly.

### research_season task



#### **How it Works**  

1. **Agent Initialization**  

   - The function initializes the `WebResearchAgent` using `WebResearchAgent.initialize_web_research_agent()`.  

   - This agent specializes in retrieving web-based agricultural knowledge.  

2. **Task Creation**  

   - A `Task` object is created via `Task.create()`, with:  

     - The **agent** assigned to perform the research.  

     - The **context** specifying the plant’s name for relevance.  

     - The **instruction** outlining key seasonal aspects to explore:  

       - **Planting & harvesting seasons** for optimal yield.  

       - **Climate conditions** including temperature and humidity.  

       - **Soil composition, nutrients, and fertilizers** best suited for growth.  

       - **Best farming practices** to maximize productivity.  

       - **Off-season storage & uses** to maintain quality and availability.  

     - The research must be backed by expert agricultural sources.  

### research_price task



1. **Agent Initialization**  

   - The function initializes the `PriceFetchingAgent` using `PriceFetchingAgent.initialize_price_fetching_agent(query=plant_name)`.  

   - This agent specializes in fetching up-to-date pricing data from online sources.  

2. **Task Creation**  

   - A `Task` object is created via `Task.create()`, with:  

     - The **agent** assigned to fetch pricing data.  

     - The **context** specifying the plant’s name for relevance.  

     - The **instruction** detailing the required price-related insights:  

       - **Online price rates** across various marketplaces.  

       - **Cheapest price available** for the plant.  

       - **Identification of the lowest available price** and its source.  

     - The research must provide **accurate and current** market data.  

### **let's now see the `agents` these tasks use**

### web_research_agent



The `WebResearchAgent` gathers key details about crops and plants using online sources.  

- **Agent Role & Goal**  

  - Acts as a **"Crop and Plant Research Agent"**, focused on collecting classification, uses, and growth data.  

  - Uses a structured, data-driven approach.  

- **LLM & Tools**  

  - Powered by `LoadModel.load_openai_model()`.  

  - Utilizes:  

    - `WikiArticles.fetch_articles` → Wikipedia data.  

    - `WikiImages.search_images` → Plant images.  

    - `ExaSearch.search_web` → Web-based insights.  

- **Error Handling**  

  - If initialization fails, an exception is raised.  

This agent ensures accurate and structured plant research.  

### price_fetching_agent



The `PriceFetchingAgent` helps find and compare the best prices for crops and plants across different markets.   

- **Agent Role & Goal**  

  - Acts as a **"Price Research Agent"**, specializing in market price analysis.  

  - Focuses on cost-conscious and data-driven price comparisons.  

- **LLM & Tools**  

  - Powered by `LoadModel.load_openai_model()`.  

  - Utilizes:  

    - `ExaShoppingSearch.search_web` → General price lookup.  

    - `SerperShoppingSearch.search_web` → Shopping-specific price comparisons.  

- **Error Handling**  

  - Raises an exception if initialization fails.

### **now let's see the `model` these `agents`  use**

**openai_gpt3.5_turbo model**



The `LoadModel` class is responsible for loading the OpenAI GPT-3.5-turbo model when required.    

- **Model Initialization**  

  - Loads `OpenaiModels.gpt_3_5_turbo` from `taskflowai`.  

  - Ensures API keys are validated **only when called**, preventing unnecessary checks.  

- **Logging & Error Handling**  

  - Logs successful model loading.  

  - Catches and logs errors, raising an exception if loading fails.  

### **now let's talk about the `tools` these `agents` have access to** 

### exa_search or exa_shopping_search tool  (these two are mostly similar) **not much difference** *defined it seperately* 



The `ExaSearch` class provides a web search functionality using the Exa API.  

- **Search Execution**  

  - Calls `WebTools.exa_search()` to fetch search results (imported from taskflowai).  

  - Allows specifying `num_results` (default: 5).  

- **API Key Validation**  

  - Ensures `EXA_API_KEY` is set in environment variables before execution.  

- **Error Handling**  

  - Logs failures and returns `"No data available"` if an error occurs.  

### search_articles tool



The `WikiArticles` class enables fetching Wikipedia articles related to a given query.   

- **Article Retrieval**  

  - Uses `WikipediaTools.search_articles()` to fetch relevant articles (imported from taskflowai).  

- **Logging & Validation**  

  - Logs the query and number of articles retrieved.  

  - Warns if no articles are found.  

- **Error Handling**  

  - Catches exceptions and logs errors while ensuring failures are properly raised. 

### search_images tool



The `WikiImages` class is responsible for fetching relevant images from Wikipedia based on a given query.  

- **Image Search**  

  - Uses `WikipediaTools.search_images()` to retrieve images related to the query (imported from taskflowai).  

- **Logging & Validation**  

  - Logs the query and number of images found.  

  - Warns if no images are available.  

- **Error Handling**  

  - Captures exceptions and logs errors to ensure smooth execution. 

### serper_shopping_search tool

*Note: when I was building this project Serper API was down or wasn't working for me (try it)* 



The `SerperShoppingSearch` class enables price research using the Serper API but falls back on `ExaShopping` due to API downtime during project development.  

- **Web Search Execution**  

  - Uses `WebTools.serper_search()` to fetch shopping-related search results.  

- **API Key Management**  

  - Loads the API key from environment variables or a `.env` file.  

  - Raises an error if the API key is missing.  

- **Error Handling**  

  - Logs and raises exceptions if the search fails. 

### **now let's talk about the `predict` route inside `app.py` the main `endpoint`.





### **Understanding the `/predict` Endpoint**  

The `/predict` route handles image-based crop detection, processes predictions, and triggers AI-powered research for detected plants.  

### **Step 1: Receiving and Decoding Image Data**  

- The endpoint expects a **base64-encoded image** in the JSON request (`request.json["image"]`).  

- The image is **decoded** using `base64.b64decode(data)`, preparing it for processing.  

- A log entry confirms the image has been successfully received and decoded.

### **Step 2: Object Detection and Processing**  

- The decoded image is passed to `process_prediction()`, where:  

  - The image is analyzed, and detected objects are identified.  

  - The function returns `labels_text`, an error (if any), and a **processed image**.  

- If an error occurs, the API returns a **500 error response**, logging the failure.

### **Step 3: Reading Detected Objects**  

- The function `read_detected_objects(DETECTED_OBJECTS_PATH)` reads from `detected_objects.txt`, which contains unique labels (plant names) identified during detection.  

- The detected objects are logged for reference.

### **Step 4: Research and Report Generation**  

- If objects were detected, the system proceeds with **AI-driven research**:  

  - `execute_research_and_report(detected_objects)` triggers research tasks for each plant, retrieving data on:

    - **General Information** (`research_overall_web()`)

    - **Health Benefits & Risks** (`research_health()`)

    - **Growth Conditions & Farming** (`research_season()`)

    - **Market Prices** (`research_price()`)

  - Results are **structured into a dictionary** and stored in `research_results`.  

  - `generate_summarized_report(research_results)` compiles a **summary** of all findings.

- If an error occurs during research, it is logged but does not stop execution.

### **now let's see the beautiful shots how it looks when exposing `port:5000` after running `app.py`**





















































### **now let's see the send_report in `app.py` that sends the email carrying your `summarized report`





This route sends the **summarized research report** via email.  

1. **Extracts request data** – Retrieves `email` and `summarized_report`, handling key mismatches.  

2. **Formats the report** – Converts HTML into **plain text**, improving readability.  

3. **Sends the email** – Uses `send_email()`, returning **200** on success or **500** on failure.  

4. **Handles errors** – Logs exceptions and responds accordingly.

*this is `send_email()` 



 

1. **Loads credentials** – Fetches `SENDER_EMAIL` and `SENDER_PASSWORD` from environment variables.  

2. **Validates credentials** – Ensures required SMTP details exist.  

3. **Creates email** – Uses `MIMEMultipart()` to format **subject & body**.  

4. **Sends via Gmail SMTP** – Establishes a **TLS-secured connection**, logs in, and dispatches the email.  

5. **Handles failures** – Logs errors and returns `False` if unsuccessful. 

*this is how summary report looks that the `receipient receives`*









### **this is when `user` clicks `end program` in UI**



Handles **graceful server shutdown** when triggered from the UI.  

1. **Receives request** – Logs the shutdown initiation.  

2. **Starts a separate thread** – Calls `shutdown_server()` to prevent request blocking.  

3. **Delays execution** – Waits **1 second** before exiting.  

4. **Forces server exit** – Calls `os._exit(0)` to terminate the application.  

5. **Handles errors** – Logs any failures and returns an error response if needed. 

---

### Welcome to Deployment and CICD related things 💚🎆🌱

*this is how deployment(CICD) looks like*

![CI_CD Diagram (3)](https://github.com/user-attachments/assets/4016020b-e3ef-49ad-ba9d-5d66a7603945)

### **CI/CD Workflow**

1. **Continuous Integration (CI)**:

   - Trigger: A new commit is pushed to the `main` branch.

   - Jenkins fetches the latest code from GitHub.

   - Docker image is built with required environment variables.

2. **Continuous Delivery (CD)**:

   - The built image is tagged and pushed to **AWS Elastic Container Registry (ECR)**.

3. **Continuous Deployment (CD)**:

   - The EC2 instance pulls the latest Docker image from ECR.

   - The existing container is stopped and replaced with the new version.

   - The Flask application is restarted with the updated image.

### **Jenkins Credentials Setup**

Make sure you have added the necessary secrets to Jenkins:

1. Go to **Manage Jenkins** > **Manage Credentials** > **System** > **Global Credentials** > **Add Credentials**.

2. Add the following credentials:

   - **aws_access_key_id**: Your AWS IAM access key  

   - **aws_secret_access_key**: Your AWS IAM secret key  

   - **openai_api_key**: Your OpenAI API key  

   - **serper_api_key**: Your Serper API key  

   - **sender_password**: Your email sender password  

   - **sender_email**: Your email sender address  

   - **exa_api_key**: Your Exa API key  

### **Note:**  

- The `Jenkinsfile` is located in the root directory and defines the CI/CD pipeline.  

- The `scripts.sh` file in the root directory contains commands to install Docker, Jenkins, and AWS CLI on the EC2 instance.

  

**Reminder:** Running inference on EC2 requires more RAM, and the AWS Free Tier won’t be sufficient.  

We have tested our Jenkins pipeline up to the Docker image build stage. However, during dependency installation and wheel setup, the Jenkins job either crashed or got stuck.  

If you encounter any issues beyond this point in the Jenkins stages, please report them as an issue in this repository, and we will address them as soon as possible (ASAP).

---

## Guide for Developers 🌿🎇✨💚🎆🌱🎇✨💚🎆

#### ⚠️ **Note for Developers**  

The model I am using in this project **is not the one trained with the modular code approach**. Instead, I trained it separately on **Google Colab using an NVIDIA A100 GPU**.  

Here are the training details:  

- **Dataset**: 25,000 images  

- **Epochs**: 100  

- **Compute**: A100 GPU (Colab Pro)  

If you want to train the model yourself, you are free to choose any **epoch size** based on your **compute resources (and budget 💰)**.  

### 📢 **Dataset Information**  

The dataset is **open-source** and available on **Hugging Face**:  

📌 **[100 Crops & Plants Object Detection Dataset (25K Images)](https://huggingface.co/datasets/devshaheen/100_crops_plants_object_detection_25k_image_dataset)**  

🔗 **Please give credit** if you use this dataset—it took **1.5 months** to annotate all the images!  

### ✅ **Using the Pretrained Model**  

To make things easier, I have already provided the **trained model (`best.pt`)** in the **project root directory**. You can use it directly for inference instead of retraining from scratch. Just check the **project files**, and you’ll find it ready to use! 🚀  

### 🛠 **Train the Model Yourself**  

If you want to train the model on a **larger epoch size**, I have already provided a **Colab Notebook** for training:  `notebooks/leaflogic_detection (soft).ipynb ` 

To train the model, open the notebook in **Google Colab**, adjust the training parameters as needed, and run the training process! 🔥  

### **Dear Developers, ** 

To create a similar project, set up your environment using Python 3.10 or above with Conda:  

```bash  

conda create -p your_env_name python=3.10

```

Activate the env:

```bash

conda activate your_env_path  

```

Then, install the required packages:

```bash

pip install -r requirements.txt  

```

You can also Run Inside a Docker Container.

The image is available on Docker Hub:  

- **Prerequisite**: Ensure Docker Desktop is installed and running on your system.

  

- Pull the image:  

```bash

  docker pull devshaheen/leaflog

```

- Run the container on port 5000:  

```bash

  docker run -it -p 5000:5000 devshaheen/leaflog

```

I recommend using TaskflowAI here because of its modularity design, which is crucial for building scalable AI/ML applications. When productionizing AI or ML apps, having a modular design from the beginning is essential.

You can fork this repo as TaskflowAI is simple and easy to understand. Here is the documentation link: [TaskflowAI Documentation](https://www.taskflowai.org/). Feel free to explore more or contribute. It provides tools to work with multi-AI agents and multi-agent system design easily, and there are also other frameworks such as Langchain's **langgraph**, **crewai**, **phi-data** etc, you can use those too.

Happy coding and building your agritech multi-AI-agent system! 🎉💚

### Project tree structure

```bash

├── Production-Ready-LeafLogic-Multi-AI-Agents-Project

├── .github/

│   └── FUNDING.yml

├── data_preparation/

│   ├── augmentation1.py

│   ├── check_duplicates3.py

│   ├── combine_augmented_and_raw_images2.py

│   ├── naming_images.py

│   ├── num_images.py

│   └── serper_scrape.py

├── docs/

│   └── agents(anatomy & types).md

├── flowcharts/

│   ├── CICD (deployment).jpg

│   ├── prediction pipeline + ai agents.jpg

│   └── training pipeline.jpg

├── log/

│   └── timestamp(log)

├── notebooks/

│   ├── agents_notebook.ipynb  

│   └── leaflogic_detection(soft).ipynb

├── src/

│   ├── leaflogic/

│   │   ├── components/

│   │   │   ├── agents/

│   │   │   │   ├── all_agents/

│   │   │   │   │   ├── __init__.py

│   │   │   │   │   ├── price_fetching_agent.py

│   │   │   │   │   └── web_research_agent.py

│   │   │   │   └── tools/

│   │   │   │       ├── __init__.py

│   │   │   │       ├── exa_search.py

│   │   │   │       ├── exa_shopping_search.py

│   │   │   │       ├── search_articles.py

│   │   │   │       └── serper_shopping_search.py

│   │   │   ├── data_ingestion.py

│   │   │   ├── model_training.py

│   │   │   └── prepare_base_model.py

│   │   ├── configuration/

│   │   │   ├── __init__.py

│   │   │   └── s3_configs.py

│   │   ├── constant/

│   │   │   └── __init__.py

│   │   ├── entity/

│   │   │   ├── __init__.py

│   │   │   ├── artifacts_entity.py

│   │   │   └── config_entity.py

│   │   ├── exception/

│   │   │   └── __init__.py

│   │   ├── logger/

│   │   │   └── __init__.py

│   │   ├── pipeline/

│   │   │   ├── __init__.py

│   │   │   ├── prediction_pipeline.py

│   │   │   └── training_pipeline.py

│   │   ├── utils/

│   │   │   ├── __init__.py

│   │   │   └── email_utils.py

│   │   └── __init__.py

│   └── __init__.py

├── templates/

│   └── index.html

├── yolov5(cloned folder)

├── .dockerignore

├── .env  (ignored by git)

├── .gitignore

├── app.py

├── best.pt

├── demo.py

├── detected_objects.txt (ignored by git)

├── Dockerfile

├── Jenkins

├── LICENSE

├── README.md

├── requirements.txt

├── scripts.sh

├── setup.py

└── template.py

```

This project is open-sourced, you can use this anywhere (even for commercial purposes etc)

--

## License 📜  

This project is licensed under the **MIT License**.  

Feel free to use, modify, and share it with proper attribution. For more details, see the [LICENSE](LICENSE) file. 🌟  ....