IOGarden

AI Plant Sustainability

Comment

Inspiration

Plants play a crucial role in reducing emissions and preserving biodiversity, making Agritech one of the most impactful applications of AI for Green. Yet, Agritech is often overlooked in modern conversations about sustainability. IOGarden was built to bridge the gap between ecological importance and everyday accessibility.

It addresses:

  • The decline in public engagement with natural vegetation due to urbanization and digital distractions

  • The gatekeeping of gardening knowledge, often locked away in outdated books or scattered across inaccessible websites

  • The massive global water waste caused by inefficient, non-data-driven irrigation systems

We didn’t need a singular moment of inspiration — why would we? The ideas were already in our heads. IOGarden came naturally to us.

What it does

IOGarden integrates geospatial data, large language models, NoSQL databases, geoquerying, and weather/ecological libraries to support sustainable plant growth. Using this data, IOGarden is able to develop an accurate care plan for any plant, tailored to local climate conditions, soil health, and species needs.

Users can identify and add plants to an interactive map, search through a global plant database, and receive AI-generated guides on optimal gardening techniques, species recommendations, and smart timers that notify them of watering needs, fertilization schedules, and temperature warnings.

IOGarden aims to open up gardening and ecology as an accessible and widespread interest to everyone.

Features

🌱 Add Plants to the Map

  • Click anywhere on the map to drop a pin, upload an image, and IOGarden automatically detect the plant species using AI and generate a custom care profile.
  • Alternatively, click the plant icon to log a plant at your current location using geolocation.

📊 View Plant Details

Click on any pin to open a detailed dashboard tailored to its location displaying:

  • Plant species name
  • Latitude and longitude
  • Watering timer
  • Optimal soil pH
  • Current temperature
  • Endangered/invasive status
  • Summary of the plant species

🗑️ Delete Plant Pins

  • Remove any plant from the map and database with a single click.

🧭 Geoquery Nearby Plants

  • Press Ctrl + K to view all plants within a custom radius around you (powered by MongoDB Atlas’ geospatial tools and a 560,000+ plant dataset)

🔎 Search Functionality

  • Use the search bar to look up any plant species and jump directly to its location on the map.

🤖 Gemini Gardening Guide

  • Click the question mark icon to access AI-generated advice and recommended plants tailored to your location and existing plant.

How we built it

IOGarden uses multiple layers of technology and tools to accomplish its tasks:

Frontend

React is the main driving force behind IOGarden's frontend as a single paged application. Each piece of functionality within IOGarden is directly built out of React Components.

Backend

Flask provides a RESTful API for the frontend to interact with. It connects to a MongoDB database to store and retrieve plant data, talks to external services such as Google Gemini and PlantNet for plant image detection, and querying plants by location. CORS is enabled to allow cross-origin requests from the frontend.

Databases

MongoDB was our choice for the database. It's stores all the plant data, including geolocation, precipitation patterns, soil pH, plant species, AI-generated care tips, and whether the plant is endangered or invasive.

Global Biodiversity Information Facility is an international open data infrastructure that provides access to data about all types of life on Earth. This dataset is our primary source for plant occurrence data. We imported 560,000+ data points into a MongoDB database as GeoJSON features, which are then used throughout the application for mapping, querying, and clustering plant locations.

APIs

MapBox powers the main map interface, rendering an interactive map that displays plant pins and supports clustering and popups. It handles user interactions such as map clicks for adding new pins, and dynamically centers on the user’s geolocation.

Gemini provides intelligent, location-aware plant recommendations and technical gardening tips. It provides personalized guides for taking care of flora, catches api fallbacks when information isn't available, and serve up up-to-date information on macro-climate trends.

WeatherAPI provides key climate metrics such as precipitation and temperature. This data allows for the development of accurate predictive models for watering schedules and climate-related concerns. For example, if temperatures spike and a plant needs to be watered earlier than originally planned.

def get_weather_data(lat, lon):
    api_key = os.getenv("WEATHER_API_KEY")  
    url = f"https://api.openweathermap.org/data/2.5/weather?lat={lat}&lon={lon}&appid={api_key}"
    try:
        response = requests.get(url, timeout=5)  
        response.raise_for_status()
        return response.json()
    except requests.exceptions.Timeout:
        print("OpenWeatherMap request timed out.")
        return {"error": "weather API timeout"}
    except requests.exceptions.RequestException as e:
        print("Weather API error:", e)
        return {"error": str(e)}

PlantNetAPI uses computer vision to used to analyze plant images and classify them by species, family, and genus. When a user adds a new plant pin, the backend sends the image to the PlantNetAPI, which returns the most likely plant match along with confidence scores and taxonomic details. This enables all users, regardless of botanical expertise, to accurately identify plants in their environment. 

def get_plantnet_data(file_paths):
    plantnet_key = os.getenv("PLANTNET_API_KEY")   
    PROJECT = "all"; 
    api_endpoint = f"https://my-api.plantnet.org/v2/identify/{PROJECT}?api-key={plantnet_key}"

    data = { 'organs': ['leaf'] }

    files = [
    ('images', (image_path, open(image_path, 'rb'))) for image_path in file_paths
    ]

    req = requests.Request('POST', url=api_endpoint, files=files, data=data)
    prepared = req.prepare()

    s = requests.Session()
    response = s.send(prepared)
    json_result = json.loads(response.text)

    return json_result

Challenges we ran into

  • Rendering pins due to inconsistencies in the data set's latitude and longitude
  • 8+ hours of frontend rendering issues
  • 2+ hours of random React white screens at 4am
  • Multiple windows blue screens of death
  • Learning MongoDB & geospatial queries
  • Finding a suitable dataset for plant data
  • Constantly hitting API rate limits and running out of requests

Accomplishments that we're proud of

We're most proud of our use of MongoDB and its geospatial data capabilities by formatting our plant detection data into a GeoJSON format. We created a 2dsphere index on the coordinates, which allowed us to perform geospatial queries such as finding nearby points, clustering pins, and running aggregation pipelines for spatial analysis. This allowed IOGarden to efficiently support features like searching for plants within a certain radius and providing location-based recommendations.

Additionally, aggregating all our API endpoints into a unified backend was a major strength of the project.

What we learned

This project was a lot of firsts for our team, including:

  • Our first time using MongoDB
  • An unprecedented number of API calls for our team
  • Multilayered API calls and JSON querying

What's next for IOGarden

  • Further training and tweaking with larger and larger datasets
  • More accurate realtime weather data to provide critical realtime alerts to users
  • Further user features, including gameification and a social system that promotes those that log large amounts of flora
  • Expansion to fauna, including the tracking of birds and other ultra-migratory species
Share this project:

Updates