Krishi AI

1 · Overview

What the product does, in simple words.

Krishi AI is a farm assistant in the browser. The name means “farming AI” in Hindi. The landing page calls it “Your Digital Krishi Sathi” (farm companion). The data and the models are for Kerala: Kerala soils, Kerala crops and the three Kerala seasons.

The app has three AI features. Each feature is a separate Python API:

• Fertilizer recommendation. The farmer enters soil type, crop, season, soil pH and the N, P and K values. Two Random Forest models give the fertilizer name and the quantity in kg per acre.
• Disease detection. The farmer uploads a photo of a leaf. A CNN picks one of 51 classes, for example Rice Brown spot, and gives a confidence value.
• Kisan Mitra chatbot. The farmer types a question. A hosted LLM (Mistral 7B) writes a short plain-text answer.

The dashboard also shows a 6-day weather forecast for Kottayam, links to government schemes, and a market price table. The market price table contains fixed demo data.

The 30-second pitch

“Krishi AI is a Next.js front end with three FastAPI microservices. The fertilizer service loads a pickled Random Forest classifier and regressor that we trained on Kerala soil data. The disease service runs a Keras CNN on a 128 × 128 leaf image and returns one of 51 crop-disease classes. The chatbot service calls Mistral-7B-Instruct through the Hugging Face Inference API with a system prompt for Indian farmers. The front end is on Vercel. Each API is a separate service on Render, so we can deploy and scale each model alone.”

What the app does not do

• It has no login and no user accounts.
• It does not save predictions, photos or chats.
• It does not get live market prices.
• It does not change the weather city. The city is always Kottayam.
• It does not translate the pages into Malayalam yet. The translation files exist, but the app does not use them.

2 · System map

Which program talks to which.

What each program owns

Why microservices

The three models need different Python stacks. TensorFlow 2.10 runs only on Python 3.10 or older. The fertilizer pickle needs scikit-learn 1.6.1 and NumPy 2, and its .python-version file says Python 3.13.1. One process cannot easily hold both stacks. Separate services also keep a crash in one model away from the others.

The cost is three cold starts on the Render free plan, three CORS lists to keep the same, and three URLs to configure in the front end.

3 · Repository layout

Every folder and the important files. The repo has one commit.

4 · Frontend pages

Next.js Pages Router. All data calls run in the browser.

Routes

Shared layout

• _app.js renders <Navbar /> above each page. The navbar is fixed at the top. It has the logo, three links (Home, Features, Our Mission) and a language menu.
• The navbar marks the active link with green text and a green underline. It uses router.pathname for this.
• The language menu has one item, English. It only changes local state. It does not change the locale.
• The feature cards come from cardsData.js. Each card is a Link with a hover zoom.
• Icons come from MUI (@mui/icons-material). The hero button uses a Font Awesome icon through CSS.

Visual style

The palette is cream (#FEF7EB), brown (#5A3C34, #462f27), sand (#e2c5a7) and field green (#3F9148). Headings use Mochiy Pop P One. Body text uses Mitr and Merriweather Sans. All three fonts are local .ttf files in public/fonts.

State in each page

Each page uses only useState and useEffect. There is no global store, no React Query and no context. Nothing persists after a reload.

Translation (i18n)

The repo installs next-i18next, i18next and react-i18next. _app.js uses appWithTranslation. But no page calls serverSideTranslations, next.config.mjs has no i18n block, and no page calls t(). The English file has 7 keys. The Malayalam file has 9 keys, and only 3 keys are the same. The result: all text is hard-coded English.

5 · Fertilizer advice

From seven numbers to a fertilizer name and a dose.

Procedure: get a fertilizer recommendation

1. Open /fertilizer.
2. Click View Reference Manual. Find the codes for your soil, crop and season.
3. Type the soil code (0 to 4), the crop code (0 to 6) and the season code (0 to 2).
4. Type the soil pH. Type the nitrogen (N), phosphorus (P) and potassium (K) values from your soil test.
5. Click Get Recommendation. The button shows “Predicting...” while it waits.
6. Read the result in the green box, for example Urea — 170.03 kg/acre.

Input codes

The codes match the LabelEncoder order that the notebook used for training. Label encoders sort names alphabetically, but this list is not alphabetical, so the codes probably came from a hand-made mapping. The training notebook is not in the repo, so you cannot check this from the code.

Data flow

What is in the pickle file

The file holds one Python dictionary with four keys. The API reads them at startup. The values below come from reading the pickle opcodes, not from loading the file.

Design points to explain

• Why Random Forest. The data is small and tabular. A forest handles mixed categorical codes and numbers well. It needs little tuning and gives feature importances.
• Why scale for trees. Trees do not need scaling. The scaler does no harm, but it is not necessary. Say this if someone asks.
• Codes as numbers. Soil, crop and season are label-encoded integers. Trees can split on them, but the order of the codes has no meaning. One-hot encoding is a cleaner choice.
• Feature-name warning. The scaler was fit on a DataFrame with column names. The API passes a plain NumPy array. scikit-learn writes a “X does not have valid feature names” warning on each call. The result is still correct.

6 · Disease detection

From a leaf photo to one of 51 classes.

Procedure: check a leaf

1. Open /disease_detect.
2. Take a clear photo of one leaf. Use daylight. Fill the frame with the leaf.
3. Drag the photo onto the drop zone, or click the drop zone and select the file.
4. Wait. The result box shows “Processing...”.
5. Read the class name and the confidence, for example Rice_Brown spot (91.4%).

Inference pipeline

CNN layers (disease_cnn.h5)

Read from the model config inside the HDF5 file. Each convolution uses a 3 × 3 kernel, padding="same", then batch normalisation and ReLU.

• About 430,000 parameters. This number is calculated from the layer sizes.
• Training settings saved in the file: loss sparse_categorical_crossentropy, metric accuracy, Adam inside a LossScaleOptimizer, mixed_float16 policy. The saved learning rate is about 1.6 × 10⁻⁵. That low value suggests a learning-rate schedule that reduced it during training.
• Global average pooling in place of Flatten keeps the head small and reduces overfitting. Dropout 0.6 is high, for the same reason.
• backend/disease_cnn.keras is a second model with 5 conv blocks (up to 512 filters) and a 256-unit dense layer. It is an HDF5 file with a .keras name. No code loads it.

Classes by crop

9 of the 51 classes are “healthy” classes. Tomato, potato, corn and pepper names follow the public PlantVillage dataset. Banana, rice, rubber, coconut and coffee classes come from other datasets and add Kerala crops.

7 · Kisan Mitra chatbot

Kisan Mitra means “farmer’s friend”.

Procedure: ask a question

1. Open /chatbot.
2. Type your question in the box, for example “Why are my paddy leaves turning yellow?”.
3. Push Enter or click the send button.
4. Read the answer in the grey bubble on the left.

How it works

• The page adds your message to the list. Then it posts {"message": "..."} to /chat.
• The API calls InferenceClient.chat_completion with model mistralai/Mistral-7B-Instruct-v0.2, max_tokens=150 and temperature=0.2.
• The system prompt makes the bot an agriculture expert for Indian farmers. It asks for short, practical, plain-text answers with no markdown, no headings, no bold and no bullet symbols. If the question is vague, the bot must ask one clarifying question.
• The API returns {"response": "..."}. The page adds it as a bot message.
• The page sends only the latest message. The bot has no memory of earlier turns.

messages=[
    {"role": "system", "content": SYSTEM_PROMPT},
    {"role": "user", "content": question},   # this line is missing
],

Why these settings

• 150 tokens keeps answers to about 100 words. That fits the chat bubble and a phone screen. It can also cut an answer in the middle of a sentence.
• Temperature 0.2 makes answers stable and less creative. That is correct for advice.
• No markdown because the page shows the text as-is. It does not render markdown.
• Hosted model because a 7B model does not fit in a free Render instance. The service only needs huggingface_hub, but its requirements file also installs TensorFlow 2.10.

8 · Weather, schemes, prices

The dashboard panel and the two static pages.

Weather card

• The card calls the OpenWeatherMap /data/2.5/forecast endpoint for Kottayam, in metric units, when it mounts.
• The forecast has one entry for each 3 hours. The card keeps the first entry of each date and shows 6 days: today large, then 5 small days.
• The icon depends on weather[0].main: Clear = sun, Clouds = cloud, Rain = drops, Thunderstorm = storm. Other values show a cloud.
• The first entry of “today” can be a night value. So the large temperature is not always the current temperature.
• If the call fails, the card shows “Loading weather...” for ever. It writes the error only to the console.

Government schemes

The links are hard-coded in dashboard.js. They open in a new tab.

Market prices

The page shows five fixed rows dated 2025-09-29: tomato, potato, onion, banana and basmati rice, in markets in Delhi and Bangalore. Each row has a trend arrow (up, down or stable). The feature card says “(under development)”. A real version can read daily mandi prices from the government Agmarknet data on data.gov.in.

Mission page

The mission is to give farmers accessible, reliable technology for crop health, fertilizer, soil quality and weather. The stated future plans are yield prediction, market price forecasting and climate-resilient farming.

9 · API tables

Every endpoint in the three services.

Errors

• A wrong JSON type gives 422 from FastAPI and Pydantic.
• A model that did not load gives 500 “Model not loaded”. In practice the service stops at startup first, because the startup hook raises RuntimeError.
• Any other error gives 500 with str(e) as the detail. This shows internal messages to the client.

Example calls

curl -X POST https://fertilizer-api-5dhb.onrender.com/predict \
  -H "Content-Type: application/json" \
  -d '{"soil_type":0,"crop_type":0,"season":0,"soil_ph":4.8,
       "nitrogen":52,"phosphorus":42,"potassium":62}'
# {"fertilizer_name":"Urea","fertilizer_amount_kg_acre":...}

curl -X POST https://disease-api-osi8.onrender.com/predict \
  -F "file=@backend/sample-leaf.jpeg"
# {"prediction":"...","confidence":...}

curl -X POST https://chatbot-api-j4zf.onrender.com/chat \
  -H "Content-Type: application/json" \
  -d '{"message":"Best time to apply potash to coconut?"}'
# {"response":"..."}

The fertilizer input above is the one row in history_kerala.csv. That row records Urea, 170.03 kg/acre for laterite soil, paddy, Virippu.

10 · Config and deploy

Environment variables, versions and hosts.

Environment variables

Versions

Pin scikit-learn exactly. A pickle made with one scikit-learn version can fail or warn when another version loads it. That is why the fertilizer service has its own environment.

Hosts

• Vercel builds the Next.js app from the repo root.
• Render runs each API as a web service with uvicorn <module>:app --host 0.0.0.0 --port $PORT.
• render.yaml defines only chatbot-api, with rootDir: backend/chatbot_api. Its start command is uvicorn main:app, but the file is chatbot_api.py. The live services were probably made in the Render dashboard, not from this file.

11 · Run it locally

Four terminals: three APIs and the web app.

1. Clone the repo.

   git clone https://github.com/MeSanskarSingh/krishi-ai
   cd krishi-ai

2. Start the fertilizer API on port 8001.

   cd backend/fertilizer_api
   python3.13 -m venv .venv && source .venv/bin/activate
   pip install -r requirements.txt
   uvicorn fertilizer_api:app --port 8001

3. In a new terminal, start the disease API on port 8002.

   cd backend/disease_api
   python3.10 -m venv .venv && source .venv/bin/activate
   pip install -r requirements.txt
   uvicorn disease_api:app --port 8002

4. In a new terminal, set your Hugging Face token and start the chatbot API on port 8003.

   cd backend/chatbot_api
   python3.10 -m venv .venv && source .venv/bin/activate
   pip install -r requirements.txt
   export HF_TOKEN=hf_your_token
   uvicorn chatbot_api:app --port 8003

5. In the repo root, make a file named .env.local with the three URLs.

   NEXT_PUBLIC_FERTILIZER_API=http://localhost:8001
   NEXT_PUBLIC_DISEASE_API=http://localhost:8002
   NEXT_PUBLIC_CHATBOT_API=http://localhost:8003

6. Install the packages and start the web app.

   npm install
   npm run dev

7. Open http://localhost:3000. The CORS lists allow this origin.
8. Do a check of each API. Open http://localhost:8001/docs, :8002/docs and :8003/docs.

12 · README vs code

The code is the truth. Know these differences before someone else finds them.

13 · Risks and bugs

Found by reading the code. Rated by how much harm they can do.

14 · Interview Q&A

Say the answers in your own words. Answers use “I” and “we”. Change them to match the part you built.

class FertilizerInput(BaseModel):
    soil_type: int = Field(ge=0, le=4)
    crop_type: int = Field(ge=0, le=6)
    season:    int = Field(ge=0, le=2)
    soil_ph:   float = Field(ge=3, le=10)
    nitrogen:  float = Field(ge=0)
    ...

15 · Numbers to know

Short facts for fast recall.

16 · Glossary

Terms in simple words.

Krishi

Farming or agriculture (Hindi).

Kisan Mitra

“Farmer’s friend”. The name of the chatbot.

Virippu

The first paddy season in Kerala, April–May to August–September. Same time as Kharif.

Mundakan

The second paddy season, September–October to December–January. The app maps it to Rabi.

Puncha

The summer season, December–January to March–April.

N, P, K

Nitrogen, phosphorus and potassium. The three main plant nutrients in a soil test.

Soil pH

How acidic the soil is. Below 7 is acidic. Laterite soils in Kerala are often near pH 5.

Laterite

A red, iron-rich, acidic soil. The most common soil in Kerala.

DAP

Diammonium phosphate. A fertilizer with nitrogen and phosphorus.

Factamfos

A complex NP fertilizer made by FACT, a company in Kerala.

18-18-18

An NPK fertilizer with 18% of each nutrient. 20-20-20 is the same idea.

kg/acre

Kilograms per acre. 1 acre is about 0.405 hectare.

Random Forest

Many decision trees trained on random samples. The forest votes (classifier) or averages (regressor).

StandardScaler

Changes each column to mean 0 and standard deviation 1.

LabelEncoder

Maps each class name to an integer and back.

Pickle

Python’s format to save objects to a file. Loading it can run code.

CNN

Convolutional neural network. A model that learns image patterns with small filters.

Batch normalisation

A layer that keeps activations at a stable scale, so training is faster.

Global average pooling

Takes the mean of each feature map. Turns 16 × 16 × 256 into 256 numbers.

Dropout

Turns off a random part of the units during training to reduce overfitting.

Softmax

Turns scores into probabilities that add up to 1.

argmax

The position of the largest value.

Mixed precision

Training with 16-bit and 32-bit numbers together to go faster.

LLM

Large language model. A program that writes text, for example Mistral 7B.

System prompt

Fixed instructions that tell an LLM its role and rules.

Temperature

How random the LLM output is. Low values give stable answers.

FastAPI

A Python web framework. It checks request data with Pydantic.

Uvicorn

The server program that runs a FastAPI app.

CORS

Browser rules that control which websites can call an API.

Cold start

The delay when a sleeping service must start before it can answer.

i18n

Internationalisation. Support for more than one language.

PlantVillage

A public dataset of leaf photos with labels for crop diseases.

17 · About this guide

The writing rules, and what the guide is based on.

This guide uses ASD-STE100 Simplified Technical English. STE is a controlled language for maintenance manuals. It makes text easy to read for people who do not speak English as a first language.

Facts come from the source code at commit c441c6d. Model details come from the model configs in the .h5 file and from the pickle opcodes. The pickle was read with pickletools and not loaded. Live endpoints were checked on 30 Oct 2026.