initial commit

.gitignore

@@ -0,0 +1,5 @@
+.env
+venv
+__pycache__
+.venv
+.env.example

Dockerfile

@@ -0,0 +1,42 @@
+# Use Python 3.12.1
+FROM python:3.12.1-slim
+
+# Prevent Python from writing .pyc files
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Ensure Python output is sent straight to terminal
+ENV PYTHONUNBUFFERED=1
+
+# Disable pip cache
+ENV PIP_NO_CACHE_DIR=1
+
+# Set working directory
+WORKDIR /app
+
+# Install required system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for Docker layer caching
+COPY requirements.txt .
+
+# Upgrade pip and install dependencies
+RUN pip install --upgrade pip && \
+    pip install -r requirements.txt
+
+# Pre-download Sentence Transformer model (optional but recommended)
+RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('BAAI/bge-small-en-v1.5')"
+
+# Copy application
+COPY . .
+
+# Hugging Face Spaces exposes port 7860
+ENV PORT=7860
+
+EXPOSE 7860
+
+# Start FastAPI
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,99 @@
+# FarmRisk Backend
+
+This is the backend service for FarmRisk, a multilingual agro-meteorological decision support platform. It is built using **FastAPI** and integrates Open-Meteo forecasts, Pinecone vector retrievals (RAG), and Gemini/Groq LLMs to generate crop-specific agricultural advisories.
+
 ---
-title: Farmrisk
-emoji: 🌖
-colorFrom: indigo
-colorTo: green
-sdk: docker
-pinned: false
+
+## Directory Structure
+
+```
+backend/
+├── app/                      # Main application package
+│   ├── api/                  # API routers (FastAPI endpoints)
+│   │   ├── advisory.py       # Handles /api/advisory (orchestrating generation & translation)
+│   │   └── location.py       # Handles /api/location (location utilities)
+│   │
+│   ├── core/                 # Core system modules
+│   │   ├── caching.py        # In-memory spatial & translation cache manager
+│   │   ├── config.py         # Global application configurations & environment loading
+│   │   └── logging.py        # Structured logging configuration
+│   │
+│   ├── llm/                  # Large Language Model services
+│   │   ├── advisory_engine.py# Core advisory prompt synthesis and generation
+│   │   └── providers.py      # LLM clients for Gemini and Groq (JSON/Text generation)
+│   │
+│   ├── models/               # Data validation schemas (Pydantic)
+│   │   └── schemas.py        # Request, Response, and Location models
+│   │
+│   ├── rag/                  # Retrieval-Augmented Generation
+│   │   └── retriever.py      # Pinecone query retriever for scientific guidelines
+│   │
+│   ├── services/             # External services and utility classes
+│   │   ├── location.py       # Nominatim reverse geocoding
+│   │   ├── season.py         # Month-based agricultural season resolver (Kharif/Rabi)
+│   │   ├── translation.py    # Multi-language translation pipeline
+│   │   └── weather.py        # Open-Meteo 10-day forecast integration & risk rules
+│   │
+│   └── main.py               # FastAPI entry point & lifespan events
+│
+├── config/                   # Static JSON configuration files
+│   ├── crops.json            # Supported crops configuration
+│   └── states.json           # Standardized Indian States configuration
+│
+├── data/                     # Data directory (scientific guides, JSON extracts)
+│
+├── pipeline/                 # Data parsing, chunking, and index uploading scripts
+│   ├── 02_parse.py           # Parse raw ICAR guides into JSON
+│   ├── 03_validate.py        # Validate guidelines format
+│   ├── 04_chunk.py           # Text chunking for vector database
+│   ├── 05_embed_upload.py    # Embed text chunks and upload to Pinecone
+│   └── run_all.py            # Master script to run the pipeline
+│
+├── rag/                      # RAG data extraction script
+│   └── extract.py            # Extract content text from PDFs
+│
+├── .env                      # Local environment variable configuration
+├── requirements.txt          # Python dependencies
+└── venv/                     # Python virtual environment
+```
+
+---
+
+## Core Components
+
+### 1. API Endpoints (`app/api/`)
+* **Advisory (`advisory.py`)**: Receives farmer coordinate location, crop, target language, and crop stage. It resolves the coordinates into village/district boundaries, retrieves the 10-day weather forecast, performs semantic vector search for ICAR guidelines, triggers Gemini/Groq to generate the summary, caches results, and runs translation.
+* **Location (`location.py`)**: Provides endpoints for searching or geocoding locations.
+
+### 2. LLM Advisory Engine (`app/llm/`)
+* **Advisory Engine (`advisory_engine.py`)**: Synthesizes the weather forecast context, risk alerts, and scientific guidelines into a prompt. It enforces strict two-paragraph output constraints, plain text styling, word count range (120-180 words), and structural partitions (expected weather in paragraph 1, recommendations in paragraph 2 ending with outlook).
+* **LLM Providers (`providers.py`)**: Integrates with the official `google-genai` SDK and the `groq` SDK, implementing retry/backoff wrappers for transient error tolerance, supporting JSON and plain-text output formats.
+
+### 3. Translation Pipeline (`app/services/translation.py`)
+* Extracts the generated `advisory_summary` and calls the translation provider.
+* Prompt rules enforce the strict preservation of double-newline paragraph breaks (`\n\n`), sentence order, wording, and meaning without rephrasing or summarizing.
+
+### 4. RAG Retriever (`app/rag/`)
+* Performs a metadata-filtered vector similarity search on the Pinecone index `farmrisk` based on selected crop, state, and resolved agricultural season to retrieve precise scientific guidelines.
+
+### 5. Weather Service (`app/services/weather.py`)
+* Connects to the Open-Meteo Forecast API.
+* Runs local rule-based evaluations for extreme temperatures, high winds, or heavy rainfall to output alert flags.
+* Generates a stable forecast hash used for temporal caching.
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Running the Backend
+
+1. **Activate the Virtual Environment**:
+   ```powershell
+   .\venv\Scripts\Activate.ps1
+   ```
+2. **Install Dependencies**:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. **Start the Development Server**:
+   ```bash
+   python -m uvicorn app.main:app --reload --host 127.0.0.1 --port 8000
+   ```

app/api/advisory.py

@@ -0,0 +1,127 @@
+from fastapi import APIRouter, HTTPException
+from typing import Dict, Any
+from app.models.schemas import AdvisoryRequest, AdvisoryResponse
+from app.services.location import NominatimLocationResolver
+from app.services.weather import WeatherService
+from app.services.season import MonthSeasonResolver
+from app.rag.retriever import AdvisoryRetriever
+from app.llm.advisory_engine import AdvisoryEngine
+from app.services.translation import TranslationService
+from app.core.caching import cache_manager
+from app.core.logging import logger
+
+router = APIRouter(prefix="/api/advisory", tags=["Advisory"])
+
+# Services
+location_resolver = NominatimLocationResolver()
+weather_service = WeatherService()
+season_resolver = MonthSeasonResolver()
+
+# Try initializing vector retriever, fallback if Pinecone config is missing/offline
+try:
+    retriever = AdvisoryRetriever()
+except Exception as e:
+    logger.warning(f"Failed to initialize AdvisoryRetriever: {e}. Falling back to empty search context.")
+    retriever = None
+
+advisory_engine = AdvisoryEngine()
+translation_service = TranslationService()
+
+@router.post("", response_model=Dict[str, Any])
+async def generate_crop_advisory(request: AdvisoryRequest):
+    """
+    Generate agrometeorological advisory for a given coordinate grid location and crop.
+    Retrieves weather context, performs Pinecone RAG search, uses Gemini Flash, and translates.
+    """
+    logger.info(
+        f"Processing advisory request: crop={request.crop}, lat={request.latitude}, lon={request.longitude}, lang={request.language}"
+    )
+
+    try:
+        # Step 1: Geocode coordinates to get state and village details
+        location_detail = await location_resolver.reverse_geocode(request.latitude, request.longitude)
+        logger.info(
+            f"Geocoded coordinates: state={location_detail.state}, district={location_detail.district}, village={location_detail.village}"
+        )
+        
+        # Step 2: Fetch current weather and compute forecast hash
+        weather_data = await weather_service.fetch_10day_forecast(request.latitude, request.longitude)
+        weather_hash = weather_data["weather_hash"]
+        
+        # Step 3: Resolve current agricultural season
+        season = season_resolver.resolve_season(request.latitude, request.longitude)
+        logger.info(f"Resolved season: {season}")
+
+        # Step 4: Spatial Cache Lookup (Check if advisory exists for this crop + location grid + weather forecast)
+        english_advisory = cache_manager.get_advisory(request.crop, request.latitude, request.longitude, weather_hash)
+        
+        if english_advisory:
+            logger.info("Advisory spatial cache HIT.")
+            # Verify structure and convert back to schema if needed
+            advisory_obj = AdvisoryResponse(**english_advisory)
+        else:
+            logger.info("Advisory spatial cache MISS. Initiating RAG pipeline.")
+            
+            # Step 5: Retrieve relevant RAG guidelines from Pinecone
+            rag_context = []
+            if retriever:
+                # Query vector database
+                rag_context = retriever.retrieve(
+                    crop=request.crop,
+                    state=location_detail.state,
+                    season=season
+                )
+            
+            logger.info(f"Retrieved {len(rag_context)} documents from Pinecone.")
+            
+            # Step 6: Generate crop advisory via Gemini Flash
+            advisory_obj = await advisory_engine.generate_advisory(
+                crop=request.crop,
+                state=location_detail.state,
+                district=location_detail.district,
+                village=location_detail.village,
+                season=season,
+                weather_data=weather_data,
+                rag_context=rag_context,
+                crop_stage=request.crop_stage
+            )
+            
+            # Save raw English advisory to spatial cache
+            cache_manager.set_advisory(
+                crop=request.crop,
+                latitude=request.latitude,
+                longitude=request.longitude,
+                weather_hash=weather_hash,
+                advisory_data=advisory_obj.model_dump()
+            )
+            logger.info("Cached raw English advisory.")
+
+        # Step 7: Translation Cache Lookup
+        english_dump = advisory_obj.model_dump()
+        translated_advisory = cache_manager.get_translation(english_dump, request.language)
+        
+        if translated_advisory:
+            logger.info(f"Translation cache HIT for language: {request.language}")
+            return translated_advisory
+            
+        logger.info(f"Translation cache MISS for language: {request.language}. Triggering translator.")
+        
+        # Step 8: Translate response values using LLM provider pipeline
+        translation_result = await translation_service.translate_advisory(advisory_obj, request.language)
+        translated_advisory = translation_result.data
+        
+        # Cache translation result only if translation succeeded
+        if translation_result.translated:
+            cache_manager.set_translation(english_dump, request.language, translated_advisory)
+            logger.info(f"Cached translation for language: {request.language}")
+        else:
+            logger.warning("Translation cache skipped because translation failed")
+        
+        # Inject resolved geographic location details into response metadata for UI display
+        translated_advisory["location"] = location_detail.model_dump()
+        
+        return translated_advisory
+
+    except Exception as e:
+        logger.error(f"Failed to generate crop advisory: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=f"Advisory generation failed: {str(e)}")

app/api/location.py

@@ -0,0 +1,19 @@
+from fastapi import APIRouter, Query, HTTPException
+from typing import List
+from app.models.schemas import LocationDetail
+from app.services.location import NominatimLocationResolver
+
+router = APIRouter(prefix="/api/location", tags=["Location"])
+resolver = NominatimLocationResolver()
+
+@router.get("/search", response_model=List[LocationDetail])
+async def search_locations(q: str = Query(..., min_length=2, description="Search term for village/city/town")):
+    """
+    Search for villages and towns in India via Nominatim.
+    Returns details (village, district, state, latitude, longitude)
+    """
+    try:
+        results = await resolver.search(q)
+        return results
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Location search failed: {str(e)}")

app/core/caching.py

@@ -0,0 +1,62 @@
+import time
+import hashlib
+from typing import Optional, Dict, Any
+from app.core.config import settings
+
+class InMemoryCache:
+    def __init__(self):
+        # Format: key -> (value, expiry_time_seconds)
+        self._cache: Dict[str, tuple] = {}
+
+    def get(self, key: str) -> Optional[Any]:
+        if key not in self._cache:
+            return None
+        val, expiry = self._cache[key]
+        if expiry and time.time() > expiry:
+            del self._cache[key]
+            return None
+        return val
+
+    def set(self, key: str, value: Any, ttl_seconds: int = 43200):
+        expiry = time.time() + ttl_seconds if ttl_seconds else None
+        self._cache[key] = (value, expiry)
+
+    def clear(self):
+        self._cache.clear()
+
+class CacheManager:
+    def __init__(self):
+        self.provider = InMemoryCache()
+        # In the future, if settings.CACHE_TYPE == "redis", we could instantiate a Redis provider.
+
+    def get_advisory(self, crop: str, latitude: float, longitude: float, weather_hash: str) -> Optional[Dict[str, Any]]:
+        # Round coordinates to 3 decimal places (approx. 110m grid accuracy)
+        lat_grid = f"{latitude:.3f}"
+        lon_grid = f"{longitude:.3f}"
+        key = f"adv:{crop.lower().strip()}:{lat_grid}:{lon_grid}:{weather_hash}"
+        return self.provider.get(key)
+
+    def set_advisory(self, crop: str, latitude: float, longitude: float, weather_hash: str, advisory_data: Dict[str, Any], ttl: int = 43200):
+        lat_grid = f"{latitude:.3f}"
+        lon_grid = f"{longitude:.3f}"
+        key = f"adv:{crop.lower().strip()}:{lat_grid}:{lon_grid}:{weather_hash}"
+        self.provider.set(key, advisory_data, ttl)
+
+    def get_translation(self, english_json: Dict[str, Any], language: str) -> Optional[Dict[str, Any]]:
+        # Generate hash of English JSON structure
+        serialized = json_stable_hash(english_json)
+        key = f"trans:{serialized}:{language.lower().strip()}"
+        return self.provider.get(key)
+
+    def set_translation(self, english_json: Dict[str, Any], language: str, translated_data: Dict[str, Any], ttl: int = 43200):
+        serialized = json_stable_hash(english_json)
+        key = f"trans:{serialized}:{language.lower().strip()}"
+        self.provider.set(key, translated_data, ttl)
+
+def json_stable_hash(data: Dict[str, Any]) -> str:
+    """Serialize dict in stable sorted way and SHA256 hash it."""
+    import json
+    serialized = json.dumps(data, sort_keys=True, ensure_ascii=False)
+    return hashlib.sha256(serialized.encode("utf-8")).hexdigest()[:16]
+
+cache_manager = CacheManager()

app/core/config.py

@@ -0,0 +1,41 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+load_dotenv(dotenv_path=BASE_DIR / ".env")
+
+class Settings:
+    # FastAPI
+    HOST: str = os.getenv("HOST", "127.0.0.1")
+    PORT: int = int(os.getenv("PORT", "8000"))
+    DEBUG: bool = os.getenv("DEBUG", "true").lower() in ("true", "1", "yes")
+    APP_ENV: str = os.getenv("APP_ENV", "development")
+    
+    # Pinecone
+    PINECONE_API_KEY: str = os.getenv("PINECONE_API_KEY", "")
+    PINECONE_INDEX_NAME: str = os.getenv("PINECONE_INDEX_NAME", "farmrisk-advisories")
+    
+    # LLM Providers Configuration
+    LLM_PROVIDER: str = os.getenv("LLM_PROVIDER", "gemini")
+    ENABLE_GROQ_FALLBACK: bool = os.getenv("ENABLE_GROQ_FALLBACK", "true").lower() in ("true", "1", "yes")
+    
+    # Gemini
+    GOOGLE_API_KEY: str = os.getenv("GOOGLE_API_KEY", "")
+    GEMINI_MODEL: str = os.getenv("GEMINI_MODEL", "gemini-3.5-flash")
+    TEMPERATURE: float = float(os.getenv("TEMPERATURE", "0.2"))
+
+    # Groq
+    GROQ_API_KEY: str = os.getenv("GROQ_API_KEY", "")
+    GROQ_MODEL: str = os.getenv("GROQ_MODEL", "llama-3.3-70b-versatile")
+    
+    # Caching
+    CACHE_TYPE: str = os.getenv("CACHE_TYPE", "in_memory")
+    REDIS_URL: str = os.getenv("REDIS_URL", "redis://localhost:6379/0")
+    ADVISORY_CACHE_TTL: int = int(os.getenv("ADVISORY_CACHE_TTL", "43200"))
+    
+    # Logging
+    LOG_FORMAT: str = os.getenv("LOG_FORMAT", "TEXT")
+    LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
+
+settings = Settings()

app/core/logging.py

@@ -0,0 +1,59 @@
+import logging
+import json
+import sys
+from app.core.config import settings
+
+class JSONFormatter(logging.Formatter):
+    def format(self, record):
+        log_entry = {
+            "timestamp": self.formatTime(record, self.datefmt),
+            "level": record.levelname,
+            "logger": record.name,
+            "message": record.getMessage()
+        }
+        if record.exc_info:
+            log_entry["exception"] = self.formatException(record.exc_info)
+        # Include extra attributes if passed
+        if hasattr(record, "extra_fields"):
+            log_entry.update(record.extra_fields)
+        return json.dumps(log_entry)
+
+def setup_logging():
+    log_level_map = {
+        "DEBUG": logging.DEBUG,
+        "INFO": logging.INFO,
+        "WARNING": logging.WARNING,
+        "ERROR": logging.ERROR,
+        "CRITICAL": logging.CRITICAL
+    }
+    
+    level = log_level_map.get(settings.LOG_LEVEL.upper(), logging.INFO)
+    logger = logging.getLogger("farmrisk")
+    logger.setLevel(level)
+    
+    # Avoid duplicate handlers
+    if logger.handlers:
+        return logger
+        
+    handler = logging.StreamHandler(sys.stdout)
+    
+    if settings.LOG_FORMAT.upper() == "JSON":
+        formatter = JSONFormatter(datefmt="%Y-%m-%dT%H:%M:%S")
+    else:
+        formatter = logging.Formatter(
+            fmt="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+            datefmt="%Y-%m-%d %H:%M:%S"
+        )
+        
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    
+    # Configure root logger lightly
+    root_logger = logging.getLogger()
+    if not root_logger.handlers:
+        root_logger.addHandler(handler)
+        root_logger.setLevel(level)
+        
+    return logger
+
+logger = setup_logging()

app/llm/advisory_engine.py

@@ -0,0 +1,126 @@
+import json
+from typing import List, Dict, Any, Optional
+from app.core.config import settings
+from app.models.schemas import AdvisoryResponse
+from app.llm.providers import get_primary_provider, get_fallback_provider
+from app.core.logging import logger
+from datetime import datetime
+
+class AdvisoryEngine:
+    def __init__(self):
+        pass
+
+    async def generate_advisory(
+        self,
+        crop: str,
+        state: str,
+        district: str,
+        village: str,
+        season: str,
+        weather_data: Dict[str, Any],
+        rag_context: List[Dict[str, Any]],
+        crop_stage: Optional[str] = None
+    ) -> AdvisoryResponse:
+        """Generate a two-paragraph plain-text agrometeorological advisory using LLMProvider and RAG context."""
+        
+        # Format the context from Pinecone
+        formatted_context = ""
+        for idx, item in enumerate(rag_context, start=1):
+            formatted_context += f"Source [{item['source']} page {item['page']}]:\n{item['content']}\n\n"
+            
+        # Format the weather data
+        formatted_weather = json.dumps(weather_data["forecast"], indent=2)
+        weather_risks = ", ".join(weather_data["risks"]) if weather_data["risks"] else "None"
+        
+        # Extract forecast period dates
+        # start_date = weather_data["forecast"][0]["date"] if weather_data["forecast"] else "N/A"
+        # end_date = weather_data["forecast"][-1]["date"] if weather_data["forecast"] else "N/A"
+        start_date = datetime.strptime(weather_data["forecast"][0]["date"], "%Y-%m-%d").strftime("%d/%m/%Y")
+        end_date = datetime.strptime(weather_data["forecast"][-1]["date"], "%Y-%m-%d").strftime("%d/%m/%Y")
+        
+        crop_stage_str = f"Crop Stage: {crop_stage}" if crop_stage else "Crop Stage: Not specified (infer from the current season and date)"
+
+        prompt = f"""
+You are an expert agrometeorologist assistant at FarmRisk.
+Generate a professional, extension-style agricultural advisory bulletin for a farmer growing {crop} in {village}, {district}, {state} during the {season} season.
+
+CROP PARAMETERS:
+- Crop: {crop}
+- {crop_stage_str}
+
+WEATHER PARAMETERS (10-Day Forecast from {start_date} to {end_date}):
+{formatted_weather}
+
+WEATHER RISK ALERTS:
+{weather_risks}
+
+AGRICULTURAL ADVISORY CONTEXT (Retrieved ICAR Scientific guidelines):
+{formatted_context}
+
+INSTRUCTIONS:
+Generate exactly one advisory consisting of exactly two paragraphs in plain text.
+- Always use indian date stamp format (DD/MM/YYYY).
+- Always highlight the important words and numbers using asterisks. Like this: *word* and *number*
+- Do NOT return JSON.
+- Do NOT use headings.
+- Do NOT use bullet points.
+- Do NOT use numbering.
+- The total length of both paragraphs combined MUST be between 120 and 180 words.
+- All text in the response must be written in English.
+
+Paragraph 1: Weather and Crop Impact
+- Must begin exactly with: "From {start_date} to {end_date}, "
+- Describe expected weather conditions and crop/soil impacts over the 10-day period.
+- Include cumulative rainfall (mm), rainfall pattern (light, moderate, or heavy), and rainfall-related risks.
+- Include minimum and maximum temperature range.
+- Include wind conditions, humidity, and expected soil moisture trend.
+- Describe the expected impact on the selected crop ({crop}).
+- This paragraph must describe ONLY weather conditions and crop impacts. Do NOT include recommendations, actions, or guidelines here.
+
+Paragraph 2: Crop Advisory
+- Provide practical crop-specific agricultural recommendations.
+- Recommendations must be based ONLY on the weather forecast, crop stage, and the retrieved ICAR advisory context. Never invent recommendations or hallucinate info.
+- Include guidance where applicable for: irrigation, sowing or transplanting, fertilizer timing, pesticide spraying (e.g., matching wind conditions), drainage management, pest/disease monitoring, and harvesting.
+- End the paragraph with exactly one concluding sentence stating the overall agricultural outlook:
+  - "Overall, the agricultural outlook for this period is Favorable."
+  - "Overall, the agricultural outlook for this period is Cautionary."
+  - "Overall, the agricultural outlook for this period is Unfavorable."
+  Choose the single option that best matches the weather and crop impact.
+"""
+
+        primary_provider = get_primary_provider()
+        fallback_provider = get_fallback_provider()
+        
+        try:
+            raw_text = await primary_provider.generate_text(
+                prompt=prompt,
+                temperature=settings.TEMPERATURE
+            )
+            logger.info(f"{settings.LLM_PROVIDER} advisory succeeded")
+            return AdvisoryResponse(advisory_summary=raw_text.strip())
+        except Exception as primary_exc:
+            logger.warning(f"Primary provider {settings.LLM_PROVIDER} failed to generate advisory: {primary_exc}")
+            
+            if fallback_provider:
+                logger.info("Switching to Groq fallback for advisory generation")
+                try:
+                    raw_text = await fallback_provider.generate_text(
+                        prompt=prompt,
+                        temperature=settings.TEMPERATURE
+                    )
+                    logger.info("Groq advisory succeeded")
+                    return AdvisoryResponse(advisory_summary=raw_text.strip())
+                except Exception as fallback_exc:
+                    logger.error(f"Fallback provider Groq failed to generate advisory: {fallback_exc}")
+            
+            logger.warning("All LLM providers failed to generate advisory. Using local English mock fallback.")
+            return self._get_mock_advisory(crop, village, start_date, end_date)
+
+    def _get_mock_advisory(self, crop: str, village: str, start_date: str, end_date: str) -> AdvisoryResponse:
+        """Fallback mock advisory for local testing without Gemini credentials."""
+        paragraph_1 = f"From {start_date} to {end_date}, the region of {village} is expected to experience a cumulative rainfall of 25 mm, characterized by a light and intermittent rainfall pattern that poses minimal immediate flood risks. Maximum temperatures will peak around 36°C while minimums drop to 23°C. These conditions will maintain moderate soil moisture trends, which is highly beneficial for the active vegetative growth phase of {crop} but may also encourage early weed emergence."
+        paragraph_2 = f"Based on the weather forecast and standard guidelines, farmers should optimize irrigation schedules by pausing watering on days with light showers and ensuring active weeding. Apply nitrogenous fertilizers during dry breaks and monitor the crop closely for sucking pests and fungal leaf spots, ensuring that drainage channels are completely clear of debris. Overall, the agricultural outlook for this period is Favorable."
+        
+        advisory_text = f"{paragraph_1}\n\n{paragraph_2}"
+        return AdvisoryResponse(advisory_summary=advisory_text)
+

app/llm/providers.py

@@ -0,0 +1,186 @@
+import asyncio
+import json
+import httpx
+from typing import Protocol, Type, TypeVar, Any, Optional
+from pydantic import BaseModel
+from google import genai
+from google.genai import types
+from google.genai.errors import APIError
+from groq import AsyncGroq
+from app.core.config import settings
+from app.core.logging import logger
+
+T = TypeVar("T", bound=BaseModel)
+
+class LLMProvider(Protocol):
+    async def generate_json(self, prompt: str, schema: Type[T], temperature: float = 0.2) -> T:
+        """Generate structured JSON response conforming to the Pydantic schema."""
+        ...
+
+    async def generate_text(self, prompt: str, temperature: float = 0.2) -> str:
+        """Generate raw plain text response."""
+        ...
+
+def is_transient_error(e: Exception) -> bool:
+    """Determine if an exception is a transient error that should be retried."""
+    # 1. APIError from google-genai SDK
+    if isinstance(e, APIError):
+        status_code = getattr(e, "code", getattr(e, "status_code", None))
+        if status_code in [429, 500, 502, 503, 504]:
+            return True
+        # Check string representation if code/status_code not found
+        err_str = str(e)
+        for code in ["429", "500", "502", "503", "504"]:
+            if code in err_str:
+                return True
+                
+    # 2. Timeout and connection errors
+    if isinstance(e, (httpx.TimeoutException, httpx.ConnectError, httpx.NetworkError, TimeoutError, asyncio.TimeoutError)):
+        return True
+        
+    # Check general error strings for transient issues
+    err_str = str(e).lower()
+    for term in ["timeout", "timed out", "connection", "network", "temporary", "unavailable", "rate limit", "resource exhausted", "deadline exceeded"]:
+        if term in err_str:
+            # Do NOT retry authentication or client-side errors
+            if any(auth_term in err_str for auth_term in ["400", "401", "403", "unauthorized", "api_key", "invalid key", "invalid credential"]):
+                return False
+            return True
+            
+    return False
+
+class GeminiProvider:
+    def __init__(self):
+        self.enabled = bool(settings.GOOGLE_API_KEY and settings.GOOGLE_API_KEY != "your_google_api_key")
+        if self.enabled:
+            self.client = genai.Client(api_key=settings.GOOGLE_API_KEY)
+        else:
+            logger.warning("GOOGLE_API_KEY not configured. GeminiProvider is running in disabled/mock state.")
+
+    async def generate_json(self, prompt: str, schema: Type[T], temperature: float = 0.2) -> T:
+        if not self.enabled:
+            raise ValueError("Gemini API key not configured or provider disabled.")
+            
+        attempts = 3
+        backoffs = [1.0, 2.0, 4.0]
+        
+        for attempt in range(1, attempts + 1):
+            try:
+                logger.info(f"Gemini attempt {attempt}/{attempts}")
+                response = self.client.models.generate_content(
+                    model=settings.GEMINI_MODEL,
+                    contents=prompt,
+                    config=types.GenerateContentConfig(
+                        response_mime_type="application/json",
+                        response_schema=schema,
+                        temperature=temperature,
+                    )
+                )
+                data = json.loads(response.text)
+                return schema.model_validate(data)
+            except Exception as e:
+                logger.warning(f"Gemini attempt {attempt} failed: {e}")
+                
+                # Check if this is a transient error and we have attempts remaining
+                if attempt < attempts and is_transient_error(e):
+                    wait_time = backoffs[attempt - 1]
+                    logger.info(f"Gemini retrying after transient error {e}. Waiting {wait_time}s...")
+                    await asyncio.sleep(wait_time)
+                else:
+                    if attempt == attempts:
+                        logger.error("Gemini retries exhausted.")
+                        if is_transient_error(e):
+                            wait_time = backoffs[attempt - 1]
+                            logger.info(f"Waiting {wait_time}s after final failure...")
+                            await asyncio.sleep(wait_time)
+                    raise e
+
+    async def generate_text(self, prompt: str, temperature: float = 0.2) -> str:
+        if not self.enabled:
+            raise ValueError("Gemini API key not configured or provider disabled.")
+            
+        attempts = 3
+        backoffs = [1.0, 2.0, 4.0]
+        
+        for attempt in range(1, attempts + 1):
+            try:
+                logger.info(f"Gemini attempt {attempt}/{attempts} (text generation)")
+                response = self.client.models.generate_content(
+                    model=settings.GEMINI_MODEL,
+                    contents=prompt,
+                    config=types.GenerateContentConfig(
+                        temperature=temperature,
+                    )
+                )
+                return response.text
+            except Exception as e:
+                logger.warning(f"Gemini text attempt {attempt} failed: {e}")
+                if attempt < attempts and is_transient_error(e):
+                    wait_time = backoffs[attempt - 1]
+                    logger.info(f"Gemini retrying after transient error {e}. Waiting {wait_time}s...")
+                    await asyncio.sleep(wait_time)
+                else:
+                    if attempt == attempts:
+                        logger.error("Gemini retries exhausted.")
+                        if is_transient_error(e):
+                            wait_time = backoffs[attempt - 1]
+                            logger.info(f"Waiting {wait_time}s after final failure...")
+                            await asyncio.sleep(wait_time)
+                    raise e
+
+
+class GroqProvider:
+    def __init__(self):
+        self.enabled = bool(settings.GROQ_API_KEY)
+        if self.enabled:
+            self.client = AsyncGroq(api_key=settings.GROQ_API_KEY)
+        else:
+            logger.warning("GROQ_API_KEY not configured. GroqProvider is running in disabled/mock state.")
+
+    async def generate_json(self, prompt: str, schema: Type[T], temperature: float = 0.2) -> T:
+        if not self.enabled:
+            raise ValueError("Groq API key not configured or provider disabled.")
+            
+        chat_completion = await self.client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt,
+                }
+            ],
+            model=settings.GROQ_MODEL,
+            response_format={"type": "json_object"},
+            temperature=temperature,
+        )
+        content = chat_completion.choices[0].message.content
+        data = json.loads(content)
+        return schema.model_validate(data)
+
+    async def generate_text(self, prompt: str, temperature: float = 0.2) -> str:
+        if not self.enabled:
+            raise ValueError("Groq API key not configured or provider disabled.")
+            
+        chat_completion = await self.client.chat.completions.create(
+            messages=[
+                {
+                    "role": "user",
+                    "content": prompt,
+                }
+            ],
+            model=settings.GROQ_MODEL,
+            temperature=temperature,
+        )
+        return chat_completion.choices[0].message.content
+
+
+def get_primary_provider() -> LLMProvider:
+    """Factory to get the primary LLM provider based on settings."""
+    if settings.LLM_PROVIDER.lower() == "groq":
+        return GroqProvider()
+    return GeminiProvider()
+
+def get_fallback_provider() -> Optional[LLMProvider]:
+    """Get the fallback provider (Groq) if configured and primary is Gemini."""
+    if settings.LLM_PROVIDER.lower() == "gemini" and settings.ENABLE_GROQ_FALLBACK:
+        return GroqProvider()
+    return None

app/main.py

@@ -0,0 +1,43 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from app.core.config import settings
+from app.core.logging import logger
+from app.api.location import router as location_router, resolver as location_resolver
+from app.api.advisory import router as advisory_router, weather_service
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup actions
+    logger.info(f"Starting FarmRisk Backend in {settings.APP_ENV} mode...")
+    yield
+    # Shutdown actions
+    logger.info("Shutting down FarmRisk Backend...")
+    await location_resolver.close()
+    await weather_service.close()
+    logger.info("FarmRisk Backend shutdown complete.")
+
+app = FastAPI(
+    title="FarmRisk AI Backend API",
+    description="Production-grade agrometeorological advisory and village resolution system.",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# Enable CORS for Next.js frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Adjust in production to frontend domain
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Mount Routers
+app.include_router(location_router)
+app.include_router(advisory_router)
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    """Simple API health check endpoint."""
+    return {"status": "healthy", "environment": settings.APP_ENV}

app/models/schemas.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+
+class LocationDetail(BaseModel):
+    village: Optional[str] = Field(None, description="Name of the village, town, or settlement")
+    district: Optional[str] = Field(None, description="Name of the district or county")
+    state: str = Field(..., description="Standardized name of the Indian State")
+    latitude: float = Field(..., description="Latitude coordinate")
+    longitude: float = Field(..., description="Longitude coordinate")
+
+class AdvisoryRequest(BaseModel):
+    latitude: float = Field(..., description="Latitude coordinate of the farmer's location")
+    longitude: float = Field(..., description="Longitude coordinate of the farmer's location")
+    crop: str = Field(..., description="Name of the crop (e.g. Cotton, Rice)")
+    language: str = Field(..., description="Target language (e.g. Gujarati, Hindi, Marathi, Tamil, English)")
+    crop_stage: Optional[str] = Field(None, description="Optional current crop stage (e.g. vegetative, flowering, maturity)")
+
+class AdvisoryResponse(BaseModel):
+    advisory_summary: str = Field(..., description="Two-paragraph professional agrometeorological advisory summary.")
+
+class TranslationResult(BaseModel):
+    data: Dict[str, Any]
+    translated: bool
+    provider: Optional[str] = None
+
+

app/rag/retriever.py

@@ -0,0 +1,69 @@
+from typing import List, Dict, Any
+from sentence_transformers import SentenceTransformer
+from pinecone import Pinecone
+from app.core.config import settings
+
+class AdvisoryRetriever:
+    def __init__(self):
+        # Local SentenceTransformer
+        self.model = SentenceTransformer("BAAI/bge-small-en-v1.5")
+        
+        # Pinecone
+        self.pc = Pinecone(api_key=settings.PINECONE_API_KEY)
+        self.index = self.pc.Index(settings.PINECONE_INDEX_NAME)
+
+    def retrieve(self, crop: str, state: str, season: str, top_k: int = 3) -> List[Dict[str, Any]]:
+        """Retrieve relevant context chunks from Pinecone using metadata pre-filtering."""
+        query_text = f"Advisory and recommendations for growing {crop} in {state} during {season} season."
+        query_vector = self.model.encode(query_text, normalize_embeddings=True).tolist()
+        
+        # Stage 1: Strict metadata filter
+        meta_filter = {
+            "crop": crop,
+            "state": state,
+            "season": season
+        }
+        
+        try:
+            response = self.index.query(
+                vector=query_vector,
+                top_k=top_k,
+                filter=meta_filter,
+                include_metadata=True
+            )
+            
+            matches = response.get("matches", [])
+            
+            # Stage 2: Fallback (if no results for specific state, query national/wider region by crop & season)
+            if not matches:
+                # Fallback filter omitting the state to capture national guidelines
+                fallback_filter = {
+                    "crop": crop,
+                    "season": season
+                }
+                response = self.index.query(
+                    vector=query_vector,
+                    top_k=top_k,
+                    filter=fallback_filter,
+                    include_metadata=True
+                )
+                matches = response.get("matches", [])
+                
+            results = []
+            for match in matches:
+                metadata = match.get("metadata", {})
+                results.append({
+                    "id": match.get("id"),
+                    "score": match.get("score"),
+                    "content": metadata.get("content", ""),
+                    "state": metadata.get("state"),
+                    "crop": metadata.get("crop"),
+                    "season": metadata.get("season"),
+                    "page": metadata.get("page"),
+                    "source": metadata.get("source")
+                })
+            return results
+            
+        except Exception as e:
+            print(f"Error querying Pinecone index: {e}")
+            return []

app/services/location.py

@@ -0,0 +1,144 @@
+import json
+from pathlib import Path
+from typing import List, Optional, Protocol
+import httpx
+from app.models.schemas import LocationDetail
+from app.core.config import settings
+
+# Load canonical states at startup
+BASE_DIR = Path(__file__).resolve().parent.parent.parent
+with open(BASE_DIR / "config" / "states.json", "r", encoding="utf-8") as f:
+    CANONICAL_STATES = json.load(f)
+
+# Helper to normalize resolved state names to the canonical ones
+def normalize_state(resolved_state: str) -> str:
+    cleaned = resolved_state.lower().strip().replace("&", "and").replace(",", "")
+    for state in CANONICAL_STATES:
+        state_clean = state.lower().replace("&", "and").replace(",", "")
+        if cleaned == state_clean or state_clean in cleaned or cleaned in state_clean:
+            return state
+    # Fallback if no match is found
+    return resolved_state
+
+class LocationResolver(Protocol):
+    async def search(self, query: str) -> List[LocationDetail]:
+        """Search location names and autocomplete to details."""
+        ...
+
+    async def reverse_geocode(self, latitude: float, longitude: float) -> LocationDetail:
+        """Resolve coordinates to detailed location schema."""
+        ...
+
+class NominatimLocationResolver:
+    def __init__(self):
+        self.client = httpx.AsyncClient(
+            timeout=10.0,
+            headers={"User-Agent": "FarmRiskAI-App/1.0 (contact@farmrisk.ai)"}
+        )
+
+    async def search(self, query: str) -> List[LocationDetail]:
+        url = "https://nominatim.openstreetmap.org/search"
+        params = {
+            "q": query,
+            "format": "json",
+            "countrycodes": "in",  # India only
+            "addressdetails": "1",
+            "accept-language": "en"
+        }
+        
+        try:
+            response = await self.client.get(url, params=params)
+            response.raise_for_status()
+            results = response.json()
+            
+            locations = []
+            for item in results:
+                address = item.get("address", {})
+                
+                # Derive village/settlement
+                village = (
+                    address.get("village") or 
+                    address.get("town") or 
+                    address.get("suburb") or 
+                    address.get("hamlet") or 
+                    address.get("neighbourhood") or 
+                    address.get("municipality") or 
+                    address.get("city")
+                )
+                
+                # Derive district
+                district = address.get("district") or address.get("county") or address.get("state_district")
+                
+                # Derive state
+                state_raw = address.get("state")
+                if not state_raw:
+                    continue
+                state = normalize_state(state_raw)
+                
+                locations.append(LocationDetail(
+                    village=village,
+                    district=district,
+                    state=state,
+                    latitude=float(item["lat"]),
+                    longitude=float(item["lon"])
+                ))
+            return locations
+            
+        except Exception as e:
+            # Return empty list in case of errors
+            print(f"Error calling Nominatim search: {e}")
+            return []
+
+    async def reverse_geocode(self, latitude: float, longitude: float) -> LocationDetail:
+        url = "https://nominatim.openstreetmap.org/reverse"
+        params = {
+            "lat": latitude,
+            "lon": longitude,
+            "format": "json",
+            "addressdetails": "1",
+            "accept-language": "en"
+        }
+        
+        try:
+            response = await self.client.get(url, params=params)
+            response.raise_for_status()
+            data = response.json()
+            address = data.get("address", {})
+            
+            village = (
+                address.get("village") or 
+                address.get("town") or 
+                address.get("suburb") or 
+                address.get("hamlet") or 
+                address.get("neighbourhood") or 
+                address.get("municipality") or 
+                address.get("city") or
+                "Unknown Village"
+            )
+            
+            district = address.get("district") or address.get("county") or address.get("state_district") or "Unknown District"
+            
+            state_raw = address.get("state") or "Rajasthan"  # Default fallback state
+            state = normalize_state(state_raw)
+            
+            return LocationDetail(
+                village=village,
+                district=district,
+                state=state,
+                latitude=latitude,
+                longitude=longitude
+            )
+            
+        except Exception as e:
+            # Fallback in case Nominatim reverse lookup fails
+            print(f"Error calling Nominatim reverse geocode: {e}")
+            return LocationDetail(
+                village="Unknown Village",
+                district="Unknown District",
+                state="Rajasthan",  # Safe fallback for Pinecone query
+                latitude=latitude,
+                longitude=longitude
+            )
+
+    async def close(self):
+        await self.client.aclose()

app/services/season.py

@@ -0,0 +1,22 @@
+from datetime import datetime
+from typing import Protocol
+
+class SeasonResolver(Protocol):
+    def resolve_season(self, latitude: float, longitude: float, date: datetime = None) -> str:
+        """Resolve agricultural season (Kharif or Rabi) for given coordinates and date."""
+        ...
+
+class MonthSeasonResolver:
+    """Standard month-based agricultural season detector for India."""
+    
+    def resolve_season(self, latitude: float, longitude: float, date: datetime = None) -> str:
+        if date is None:
+            date = datetime.now()
+            
+        month = date.month
+        
+        # In India, Kharif season is June - October; Rabi season is November - May
+        if 6 <= month <= 10:
+            return "Kharif"
+        else:
+            return "Rabi"

app/services/translation.py

@@ -0,0 +1,116 @@
+import json
+from typing import Dict, Any, List, Optional, Tuple
+from app.core.config import settings
+from app.models.schemas import AdvisoryResponse, TranslationResult
+from pydantic import BaseModel
+
+class TranslationResponse(BaseModel):
+    translations: List[str]
+
+from app.llm.providers import get_primary_provider, get_fallback_provider
+from app.core.logging import logger
+
+class TranslationService:
+    def __init__(self):
+        pass
+
+    async def translate_advisory(self, advisory: AdvisoryResponse, target_language: str) -> TranslationResult:
+        """Translate the values of the AdvisoryResponse into the target language."""
+        if not target_language or target_language.lower() == "english":
+            return TranslationResult(
+                data=advisory.model_dump(),
+                translated=True,
+                provider=None
+            )
+
+        # Step 1: Extract and flatten text fields to translate
+        texts_to_translate = [advisory.advisory_summary]
+        
+        # Step 2: Batch translate using providers
+        translated_texts, provider = await self._batch_translate(texts_to_translate, target_language)
+        
+        if translated_texts is None or not translated_texts:
+            # Translation failed completely
+            logger.warning("Translation failed. Returning original English advisory.")
+            return TranslationResult(
+                data=advisory.model_dump(),
+                translated=False,
+                provider=None
+            )
+            
+        # Step 3: Reconstruct the advisory dictionary
+        try:
+            translated_data = {
+                "advisory_summary": translated_texts[0]
+            }
+            return TranslationResult(
+                data=translated_data,
+                translated=True,
+                provider=provider
+            )
+        except Exception as e:
+            logger.error(f"Error reconstructing translation data: {e}")
+            return TranslationResult(
+                data=advisory.model_dump(),
+                translated=False,
+                provider=None
+            )
+
+
+    async def _batch_translate(self, texts: List[str], target_language: str) -> Tuple[Optional[List[str]], Optional[str]]:
+        # Check if settings allow actual provider runs
+        # If no keys are set, fallback to mock translator
+        has_gemini = bool(settings.GOOGLE_API_KEY and settings.GOOGLE_API_KEY != "your_google_api_key")
+        has_groq = bool(settings.GROQ_API_KEY)
+        
+        if not has_gemini and not has_groq:
+            # Mock translator: just appends language suffix
+            logger.info("Running translation in mock mode (no provider keys configured)")
+            mocked = [f"{text} [{target_language}]" for text in texts]
+            return mocked, None
+            
+        prompt = f"""
+You are a precise translator. Translate the following list of strings from English into {target_language}.
+
+RULES:
+1. Maintain the exact order and number of elements in the list.
+2. Return a JSON object with a key "translations" containing the array of translated strings of the exact same length.
+3. Translate the meaning accurately. Do not summarize, rephrase, rewrite, or add any formatting.
+4. Keep technical agricultural terms accurate in the target language.
+5. Crucially, preserve paragraph separation (e.g. double newlines), exact wording, meaning, and sentence order. Do not regenerate the advisory, do not summarize, and do not rewrite.
+
+
+Input list:
+{json.dumps(texts, ensure_ascii=False)}
+"""
+
+        primary_provider = get_primary_provider()
+        fallback_provider = get_fallback_provider()
+        
+        # Try primary provider
+        try:
+            result = await primary_provider.generate_json(
+                prompt=prompt,
+                schema=TranslationResponse,
+                temperature=0.1
+            )
+            logger.info(f"{settings.LLM_PROVIDER} translation succeeded")
+            return result.translations, settings.LLM_PROVIDER.lower()
+        except Exception as primary_exc:
+            logger.warning(f"Primary provider {settings.LLM_PROVIDER} failed translation: {primary_exc}")
+            
+            # Switch to Groq fallback
+            if fallback_provider:
+                logger.info("Switching to Groq fallback for translation")
+                try:
+                    result = await fallback_provider.generate_json(
+                        prompt=prompt,
+                        schema=TranslationResponse,
+                        temperature=0.1
+                    )
+                    logger.info("Groq translation succeeded")
+                    return result.translations, "groq"
+                except Exception as fallback_exc:
+                    logger.error(f"Fallback provider Groq failed translation: {fallback_exc}")
+                    
+        return None, None

app/services/weather.py

@@ -0,0 +1,115 @@
+import hashlib
+import httpx
+from typing import Dict, Any, List
+
+class WeatherService:
+    def __init__(self):
+        self.client = httpx.AsyncClient(timeout=10.0)
+
+    async def fetch_10day_forecast(self, latitude: float, longitude: float) -> Dict[str, Any]:
+        """Fetch 10-day meteorological data from Open-Meteo."""
+        url = "https://api.open-meteo.com/v1/forecast"
+        params = {
+            "latitude": latitude,
+            "longitude": longitude,
+            "daily": "temperature_2m_max,temperature_2m_min,precipitation_sum,wind_speed_10m_max,relative_humidity_2m_max",
+            "timezone": "auto",
+            "forecast_days": 10
+        }
+        
+        try:
+            response = await self.client.get(url, params=params)
+            response.raise_for_status()
+            data = response.json()
+            
+            daily = data.get("daily", {})
+            time_list = daily.get("time", [])
+            temp_max = daily.get("temperature_2m_max", [])
+            temp_min = daily.get("temperature_2m_min", [])
+            precip = daily.get("precipitation_sum", [])
+            wind = daily.get("wind_speed_10m_max", [])
+            humidity = daily.get("relative_humidity_2m_max", [])
+            
+            forecast = []
+            for idx, date_str in enumerate(time_list):
+                forecast.append({
+                    "day": idx + 1,
+                    "date": date_str,
+                    "temp_max": temp_max[idx] if idx < len(temp_max) else None,
+                    "temp_min": temp_min[idx] if idx < len(temp_min) else None,
+                    "precipitation_sum": precip[idx] if idx < len(precip) else 0.0,
+                    "wind_speed_max": wind[idx] if idx < len(wind) else 0.0,
+                    "humidity_max": humidity[idx] if idx < len(humidity) else 0.0
+                })
+                
+            # Perform rule-based risk evaluation
+            risks = self._assess_risks(forecast)
+            
+            # Generate a hash for spatial/temporal caching
+            weather_hash = self._generate_weather_hash(forecast)
+            
+            return {
+                "forecast": forecast,
+                "risks": risks,
+                "weather_hash": weather_hash
+            }
+            
+        except Exception as e:
+            print(f"Error fetching weather forecast: {e}")
+            # Fallback mock/empty weather forecast so RAG doesn't crash the server
+            fallback_forecast = []
+            for d in range(1, 11):
+                fallback_forecast.append({
+                    "day": d,
+                    "date": f"Day {d}",
+                    "temp_max": 30.0,
+                    "temp_min": 20.0,
+                    "precipitation_sum": 0.0,
+                    "wind_speed_max": 10.0,
+                    "humidity_max": 60.0
+                })
+            return {
+                "forecast": fallback_forecast,
+                "risks": ["No current warnings. (Weather API Offline fallback)"],
+                "weather_hash": "offline_fallback"
+            }
+
+    def _assess_risks(self, forecast: List[Dict[str, Any]]) -> List[str]:
+        warnings = []
+        has_heatwave = False
+        has_heavy_rain = False
+        has_gale = False
+        has_frost = False
+        
+        for day in forecast:
+            tmax = day.get("temp_max") or 0.0
+            tmin = day.get("temp_min") or 0.0
+            prec = day.get("precipitation_sum") or 0.0
+            wind = day.get("wind_speed_max") or 0.0
+            
+            if tmax > 42.0 and not has_heatwave:
+                warnings.append("Extreme Heat Alert: Maximum temperatures exceeding 42°C expected.")
+                has_heatwave = True
+            if tmin < 5.0 and not has_frost:
+                warnings.append("Frost Warning: Night temperatures dropping below 5°C expected.")
+                has_frost = True
+            if prec > 40.0 and not has_heavy_rain:
+                warnings.append(f"Heavy Rain Advisory: Daily precipitation exceeding 40mm predicted (Day {day['day']}).")
+                has_heavy_rain = True
+            if wind > 35.0 and not has_gale:
+                warnings.append(f"High Wind Warning: Wind gust speeds exceeding 35 km/h expected (Day {day['day']}).")
+                has_gale = True
+                
+        return warnings
+
+    def _generate_weather_hash(self, forecast: List[Dict[str, Any]]) -> str:
+        """Create a hash of the forecast parameters (rounded) to check cache stability."""
+        hash_string = ""
+        for day in forecast[:5]:  # Focus on next 5 days for stability
+            tmax = round(day.get("temp_max") or 30.0)
+            prec = round(day.get("precipitation_sum") or 0.0, 1)
+            hash_string += f"{tmax}:{prec}|"
+        return hashlib.sha256(hash_string.encode()).hexdigest()[:12]
+
+    async def close(self):
+        await self.client.aclose()

config/crops.json

@@ -0,0 +1,56 @@
+[
+  "Rice",
+  "Paddy",
+  "Wheat",
+  "Cotton",
+  "Maize",
+  "Millets",
+  "Bajra",
+  "Jowar",
+  "Barley",
+  "Groundnut",
+  "Soybean",
+  "Mustard",
+  "Rapeseed",
+  "Sesame",
+  "Sunflower",
+  "Castor",
+  "Linseed",
+  "Sugarcane",
+  "Chickpea",
+  "Lentil",
+  "Pea",
+  "Black gram",
+  "Green gram",
+  "Moong",
+  "Urad",
+  "Tur",
+  "Pigeonpea",
+  "Cowpea",
+  "Tomato",
+  "Brinjal",
+  "Okra",
+  "Onion",
+  "Garlic",
+  "Potato",
+  "Cabbage",
+  "Cauliflower",
+  "Chilli",
+  "Capsicum",
+  "Cucumber",
+  "Pumpkin",
+  "Bottle gourd",
+  "Ridge gourd",
+  "Bitter gourd",
+  "Banana",
+  "Mango",
+  "Papaya",
+  "Guava",
+  "Coconut",
+  "Arecanut",
+  "Turmeric",
+  "Ginger",
+  "Black Pepper",
+  "Grapes",
+  "Pomegranate"
+]

config/states.json

@@ -0,0 +1,36 @@
+[
+  "Andaman & Nicobar Islands",
+  "Andhra Pradesh",
+  "Arunachal Pradesh",
+  "Assam",
+  "Bihar",
+  "Chhattisgarh",
+  "Goa",
+  "Gujarat",
+  "Haryana",
+  "Delhi",
+  "Haryana & Delhi",
+  "Himachal Pradesh",
+  "Jammu and Kashmir",
+  "Jharkhand",
+  "Karnataka",
+  "Kerala",
+  "Ladakh",
+  "Lakshadweep",
+  "Madhya Pradesh",
+  "Maharashtra",
+  "Manipur",
+  "Meghalaya",
+  "Mizoram",
+  "Nagaland",
+  "Odisha",
+  "Punjab",
+  "Rajasthan",
+  "Sikkim",
+  "Tamil Nadu",
+  "Telangana",
+  "Tripura",
+  "Uttar Pradesh",
+  "Uttarakhand",
+  "West Bengal"
+]

data/extracted/inspect_icar.txt

@@ -0,0 +1,416 @@
+Total Pages: 310
+
+================ Page 5 ================
+(ii)
+eSa bl egRoiw.kZ iqLrd ds fy, blds laikndksa] oSKkfudksa] foLrkj dk;ZdrkZvksa ,oa lHkh 
+lgHkkxh laLFkkvksa dks c/kkbZ nsrk gw¡] ftUgksaus [kjhQ ekSle dh [ksrh ds fy, ,d mi;ksxh] 
+ljy ,oa çHkkoh ijke'kZ xkbM rS;kj dh gSA eq>s iw.kZ fo'okl gS fd ;g iqLrd gekjs 
+vUunkrkvksa dks [kjhQ Qlyksa dh oSKkfud [ksrh gsrq l'kä ekxZn'kZu çnku djsxh] 
+ftlls mudh mit] vk; ,oa thou Lrj esa mÙkjksÙkj lq/kkj gksxkA
+vkb,] ge lc feydj —f"k {ks= dks l'kä cuk,a] rkfd ,d le`)] vkRefuHkZj vkSj 
+fVdkÅ ^fodflr Hkkjr* ds lius dks lkdkj fd;k tk ldsA
+vk/kkfjr fu.kZ; vkSj mUur rduhdksa dh tkudkjh lqyHk :i esa çnku djsxhA ;g ç;kl 
+u dsoy [ksrh dks vf/kd ykHkdkjh cukus esa enn djsxk] cfYd ^fodflr Hkkjr &2047* ds 
+gekjs jk"Vªh; ladYi dks Hkh l'kä vk/kkj çnku djsxkA
+t; toku] t; fdlku] t; foKku] t; vuqla/kkuA
+Hkkjr ekrk dh t;A
+
+
+================ Page 10 ================
+I congratulate the scientists, editors, and extension professionals involved in 
+compiling this publication. I also encourage ϐield functionaries and stakeholders to 
+use this resource extensively to support farmers during the Kharif season.
+Let us continue to work together to transform Indian agriculture into a more 
+resilient, productive, and sustainable sector.
+This book compiles region-speciϐic advisories that reϐlect the latest research and 
+ϐield-level insights from ICAR institutes, Agricultural Universities, and Krishi Vigyan 
+Kendras (KVKs) across the country. It is designed to serve as a practical guide for 
+extension personnel, progressive farmers, farmer producer organizations (FPOs), 
+and agri-entrepreneurs engaged in Kharif crop planning and management. The 
+advisories encompass timely, location-speciϐic, and scientiϐically backed 
+recommendations and cover major crops, livestock, and ϐisheries, with a focus on 
+improving productivity, proϐitability, and sustainability.
+At ICAR, we believe that technology transfer and knowledge dissemination are as 
+vital as research itself. The role of the extension system, particularly KVKs, has been 
+pivotal in bridging the gap between research institutions and farming communities. 
+This book is a result of collaborative efforts between research and extension systems 
+and exempliϐies our commitment to farmer-centric innovation.
+(Rajbir Singh)
+India's agricultural landscape is rich in diversity, yet increasingly inϐluenced by 
+climatic uncertainties, resource constraints, and changing socio-economic 
+dynamics. To address these challenges effectively, there is a growing need to equip 
+farmers with timely, localized, and scientiϐically validated information that enhances 
+their decision-making capacity. This compilation “ICAR Kharif Agro-Advisories for 
+Farmers 2025” is a well-conceived effort in this direction.
+Dr. Rajbir Singh
+Deputy Director General (Agricultural Extension), ICAR
+(vii)
+PREFACE
+
+
+================ Page 20 ================
+Andhra Pradesh
+Godavari Zone: Swarna, Indra, Amara, Bhima, Pushyami, Ksheera, Sravani, 
+Maruteru Samba & Masoori, MTU 1212, 1280, 1281, 1293, 1310, 1321, 1318, 1232, 
+Varieties
+Late Nursery Transplanting: Swarna, Indra, Amara, Maruteru Masoori, MTU Rice 
+1318, Bapatla Masoori, Bhavapuri Sannalu, Teja, Panduranga, MCM Rice 103. BPH 
+(Brown Plant Hopper) Infestation-Prone Areas: Krishnaveni, Indra, Amara, 
+Maruteru Samba & Masoori, MTU 1271, Bhavapuri Sannalu, Teja, Sasya, BPT Rice 
+2846, Nellore Siri. 
+CEREAL CROPS
+North Coastal Zone: Pushkala, Srisatya, Cotton Dora Sannalu, Tarangini, Nellore 
+Masoori, Nellore Dhanyarashi, NLR Rice 3238. 
+HAT Zone: Cotton Dora Sannalu, Tarangini, Chandra, Pushkala, Srisatya, NLR 3238. 
+Krishna Zone: Swarna, Indra, Amara, Krishnaveni, Varam, MTU Rice 1318, MTU 1232, 
+Panduranga, MCM Rice 103, Samba Masoori, Akshaya, Bhavapuri Sannalu, Bapatla 
+Masoori, Nellore Siri, Teja, Bhavathi, Sasya, BPT Rice 2841 & 2846, Maruteru Samba, 
+Maruteru Masoori, MTU Rice 1271 & 1278, Nellore Sona, Nellore Siri, NLR 3238. 
+Flood-Prone Areas: Amara, Indra, Bhima, MTU Rice 1232 & 1318. Saline Soils: Indra, 
+Panduranga, MCM Rice 103. 
+Paddy
+Late Planting: Cotton Dora Sannalu, Tarangini, MTU 1293, Nellore Sona, Nellore 
+Masoori, Nellore Siri, NLR 3238. 
+Drought-Prone Areas: Cotton Dora Sannalu, Vijetha, Tarangini, Chandar, MTU 1293, 
+NLR 3238.
+Southern Zone: Sweta, Bharani, Somasila, Nellore Masoori, Nellore Dhanyarashi, 
+Nellore Sugandha, NLR 3238, Cotton Dora Sannalu, Tarangini, Chandra. 
+5
+
+
+================ Page 30 ================
+Andhra Pradesh
+Stage-Based Feeding: Implement a feeding strategy based on the pig's life stages for 
+optimal growth.
+Sheep Farming
+Health & Disease Control: Implement regular vaccination and deworming 
+schedules and provide practical training on poultry health management.
+Young Lamb Management: Ensure colostrum feeding, deworming, and timely 
+vaccinations to improve lamb health and reduce mortality.
+Heifers & Dairy Animals: Provide mineral supplementation, hormonal 
+interventions for repeat breeding, and manage endometritis to improve 
+reproductive efϐiciency.
+Backyard Poultry Farming
+Housing & Welfare: Use low-cost, secure enclosures for bird safety, and improve 
+transportation practices to reduce stress.
+Feeding Strategies: Promote Azolla cultivation as a cost-effective, high-protein feed 
+supplement and use locally available feed ingredients to cut costs.
+Swine Farming
+Breed Improvement: Replace non-descriptive breeds with the SVVU T-17 breed to 
+enhance productivity. 
+Dairy Buffaloes: Promote clean milking practices, calcium supplementation to 
+prevent milk fever, and strategies to avoid ketosis and ruminal acidosis.
+Breed Improvement: Replace native low-productive breeds with high-
+performance breeds like Rajasri and Gramapriya.
+Feeding Strategy: Avoid feeding swill and provide balanced concentrate feed to 
+improve reproductive performance.
+Fodder Supply: Promote high-yielding fodder varieties, use crop residues, and 
+implement silage making to combat fodder shortages. Provide green fodder during 
+the day and roughages at night to manage heat stress.
+Breeding Stock: Replace non-descriptive breeds with the Macherla breed, which is 
+well-adapted to local conditions.
+Supplementary Feeding & Genetic Diversity: Provide supplementary feeding 
+during pregnancy and exchange rams for improved genetic diversity.
+Sub soiler results cutting soil strata up to a depth of 40 to 75 cm and creates more 
+space for rain water entry and storage. In-situ water conservation and to sustain 
+crop in prolonged dry spell. Easily operated by any 35 to 45 hp tractor. It is useful in 
+dryland agricultural crops.  Use Trampler for green manure mixing, it cuts and 
+presses green manure leaves into the soil, helping them decompose efϐiciently and 
+FARM MACHINERY & TOOLS 
+Agricultural Crops
+Health Management: Ensure regular deworming and vaccination schedules, and 
+administer iron dextran injections to piglets to reduce mortality.
+15
+
+
+================ Page 40 ================
+Assam
+Transplanting: One ploughing should be given at least 21 days prior to 
+transplanting. An irrigation for land soaking should be applied before preparatory 
+tillage. The ϐinal puddling should be done 4-5 days prior to transplanting. One 
+irrigation should be applied before ϐinal puddling. 25 days old seedlings of short and 
+medium duration varieties should be transplanted by maintaining a row-to-row and 
+plant-to-plant spacing of 20 cm × 15 cm. In case of long duration varieties, 35-40 days 
+old seedlings are to be transplanted at 25 cm × 15 cm spacing. It is advised to plant 2-
+3 seedlings per hill, at a depth of 4-5 cm, for all varieties.
+Nutrient management: Well rotten FYM or compost @ 10 t/ha has to be applied during 
+ϐield preparation. In addition, for semidwarf varieties, 60 kg N/ha, 20 kg P₂O₅/ha and 40 
+kg K₂O/ha and for tall varieties, 20 kg N/ha, 10 kg P₂O₅/ha and 10 kg K₂O/ are to be 
+applied in areas with moderate fertility level. In case of poor soil, the rates of fertilizers 
+may be required to increase to the extent of 60:30:30 kg/ha N, P₂O₅ and K₂O respectively. 
+Half of urea and whole of super phosphate and muriate of potash should be applied at the 
+time of ϐinal puddling. Of the remaining part of urea, half at tillering stage i.e. 20-30 days 
+after transplanting and other half at panicle initiation stage should be applied. Two 
+weedings should be given with paddy weeder or hoe at 20 and 40 days after 
+transplanting. For weed control, pretilachlor @ 0.75 kg/ha or anilofos is to be applied @ 
+0.4 kg/ha at 3 days after transplanting. In sali rice, application of 5 cm irrigation water 3 
+days after disappearance of ponding water is recommended in medium and heavy soils. 
+In rainfed kharif rice, height of bunds should be 30 cm to retain rainwater.
+Plant protection measures: To control the rice stem borer, whorl maggot, gall 
+midge and leaf folder, spray ϐipronil 5SC @1.5-2 ml/l of water. To control thrips and 
+plant hopper, spray imidacloprid 70 WG @0.3 g/l of water or thiamethoxam 25 
+WG@0.03 g/l of water. Against Rice Hispa, spray lamda-cyhalothrin 5 EC @ 12.5g 
+/per ha.  To control rice pests, erect 50 'T'-perches per ha 2 ft (60 cm) above crop 
+canopy as roosting site for insectivorous birds, which are to be removed before 
+ϐlowering in order to prevent activity of granivorous birds. To prevent rice blast, 
+spray hexaconazole 5EC @ 2g/l of water at tillering stage (40-55 days after sowing) 
+and subsequently give two more sprays of ediphenphos @ 1ml/l of water, one at 
+panicle initiation stage and the other when the tip of the panicle just comes out.
+Management of direct seeded late Sali: Field should be prepared just after 
+recession of ϐlood by ploughing, cross ploughing and laddering to bring it to a puddle 
+Seedlings of Flood Tolerant Rice variety-
+Ranjit sub-1 during ϐlood
+Installation of T Perch in Rice Field
+25
+
+
+================ Page 50 ================
+Bihar
+Nutrient management involves basal application of 20:40:30 kg/ha N:P₂O₅: K₂O 
+(through urea, SSP, and MOP), with an additional 250 kg/ha gypsum at ϐlowering for 
+better pod development. In zinc-deϐicient soils, apply 25 kg ZnSO₄/ha. Provide life-
+saving irrigation at ϐlowering and pod development stages if monsoon rains are 
+erratic. Proper soil moisture during pegging is crucial for good pod formation. Major 
+pests and diseases include leaf spot, collar rot, aphids and bud necrosis virus. Leaf 
+spots can be managed by spraying Mancozeb 75 WP @2.5 g/L while sucking pests 
+should be controlled using Imidacloprid 17.8 SL 0.3 ml/L. Harvest should be done 
+when most leaves yellow and pods mature internally (dark shell markings). Avoid 
+delay in harvesting to prevent aϐlatoxin contamination. Under recommended 
+practices, yields of 15-18 q/ha can be achieved with potential to exceed 25 q/ha 
+under favourable conditions. Storing of oilseed in new bags after proper sun drying 
+and treatments. Farmers are advised to purchase the inputs like seed, fertilizers and 
+fungicide for seed treatment well in advance. 
+FRUIT & VEGETABLE  CROPS
+Farmers are advised to grow fruit crops like Mango, Litchi, Guava, Papaya and Citrus 
+fruit. Irrigate mango and litchi plants at weekly interval for proper fruit growth and 
+development. To control premature fruit dropping in mango and litchi, farmers are 
+advised to spray Planoϐix@4ml/10 L of water at an interval of 10-12 days. Fruit 
+cracking is major problem in Litchi, it can be prevented with regular irrigation, 
+mulching and fresh water spraying during dry spells. For better fruit development 
+farmers are advice to apply n-triacontanol (Miraculan) @0.5 ml/L and moisture 
+conservation can be done by the practice of basin mulching using straw/grasses. For 
+control of mango mealy bug spraying of Dimethoate 30EC @1.0 ml/L or Neem oil 
+@5ml/L twice at 10-12 days interval followed by 2 spray of Planoϐix @4 ml/10 L 
+water at 10-12 interval to check fruit drop. 
+For fruit borer in mango, spray chlorpyriphos 50 % EC+Cypermethrin 5% EC @2.5 
+ml/L water or Lamda-cyhalothrin 5% EC @0.5 ml /L water or Indoxacarb 14.5 SC 
+@0.5 -1 ml /L water. For fruit ϐly control, spray Deltamethrin 2.8 EC @1 ml/L water or 
+Spinoza 45 SC @1 ml/water at 15 days internal. For setting of pheromone traps in 
+mango orchards, 10 traps per ha is advised in Mango orchards. For Mango hopper, 
+spray with Imidacloprid 17.8 SL @0.5- 1 ml/L water at 15 days internal. To control 
+Field preparation
+35
+
+
+================ Page 60 ================
+Chhattisgarh
+Poultry
+During this hot summer provide good ventilation, maintain proper shed temperature 
+and make availability of ample cold drinking water to maintain body temperature of 
+birds. Use anti-stress vitamins such as vimeral to increase immunity and to reduce 
+climate stress. Local poultry farmers are advised to feed concentrate mix with local 
+available grain in ratio of 2:1 in the diet to maintain the health and growth of poultry 
+birds during the scarcity of quality feed. The moisture and quality of the litter materials 
+in poultry shed need to be maintain to prevent coccidiosis infestation. All the 
+equipment in the shed should be disinfected using hot water and with any other proper 
+disinfectant. Disinfect the premises of poultry houses with 1% sodium hypochlorite 
+and inhibit the entry of outsider to the poultry houses and premises. Poultry farmers 
+are advised to vaccinate the chicks at the age of 5-7 days against Ranikhet disease. 
+Ensure vaccination of chicks against Ranikhet disease, if not done earlier. 
+Deworm the birds using piperazine before onset of monsoon season. After removing 
+adult birds from the previous ϐlock, thoroughly clean and disinfect the poultry shed. 
+Maintain a 3 to 4-week gap between two ϐlocks to ensure ϐloor and environment 
+sanitation (known as downtime). Use a brooder guard to create a circular space about 5 
+feet in diameter; this is sufϐicient for about 200 to 250 chicks. Place a heat source (such 
+as infrared bulb, regular bulb, or gas brooder) in the center of the circle. Spread a 2-inch 
+thick layer of straw or wood shavings inside the circle and cover it with old newspaper. 
+Arrange feeders and drinkers in a circular pattern like the spokes of a wheel. 
+FOOD AND NUTRITION
+During the summer, farmers and farm women should prioritize staying hydrated, 
+consuming seasonal fruits and vegetables, and maintaining a balanced diet rich in protein 
+and ϐiber. It is important to remain vigilant about food safety during the hot season and focus 
+on nutrient-rich, easily digestible meals. Heat can cause dehydration, so drink water 
+frequently throughout the day, not just when you feel thirsty.  Avoid sugary drinks, they can 
+lead to dehydration and other health issues. Summer offers a variety of nutritious options 
+like watermelon, mangoes, cucumbers, and tomatoes. Always choose local produce, it is 
+often fresher and more affordable. Include protein rich foods like lentils, beans, chickpeas, 
+and paneer are excellent sources of protein. Eat ϐiber-rich foods like whole grains, 
+vegetables, and fruits support digestion and help prevent constipation. Prefer light and 
+refreshing foods, salads and curd can be easier to digest during summer. Avoid heavy, fried, 
+or processed foods. These can be hard to digest and may contribute to dehydration.
+Pit for planting of fruit sapling
+Vaccination of animals
+45
+
+
+================ Page 70 ================
+Gujarat
+For millet cultivation use high-yielding, region-appropriate varieties such as GPU 
+28, CO 13, and PR 202 for ϐinger millet; OLM 203 and OLM 205 for little millet; and 
+SiA 3085 and SiA 3156 for foxtail millet. The best sowing window is from mid-June 
+to mid-July, coinciding with the onset of the monsoon. Land preparation involves 
+ploughing 2-3 times to achieve a ϐine tilth, followed by levelling the ϐield to ensure 
+proper drainage. The recommended seed rate for line sowing is 8-10 kg per 
+hectare, with row spacing of 22.5-30 cm and plant-to-plant spacing of 8-10 cm. Use 
+Thiram or Carbendazim at 2 g/kg for seed treatment and to protect against seed-
+borne diseases. Fertilizer application should include 40 kg of nitrogen, 20 kg of 
+phosphorus, and 20 kg of potassium per hectare. Apply full dose of phosphorus 
+and potassium, along with half of the nitrogen, at sowing, and the remaining 
+nitrogen at 30 days after sowing (DAS). Weed management can be achieved with 
+the ϐirst weeding at 15-20 DAS and the second at 30-35 DAS, using inter-cultivation 
+or a pre-emergence herbicide like Pendimethalin at 1.0 kg/ha. 
+During the monsoon, ensure good drainage to prevent water stagnation. Intercultural 
+operations should include keeping the ϐield weed-free and mulching around the base of 
+The ideal planting time for bananas is during June-July, coinciding with the onset of 
+the monsoon. Recommended varieties include Grand Naine (G9), Dwarf Cavendish, 
+Basrai, Shrimanti, and BRS-1, depending on local suitability. For land preparation, 
+deep ploughing and leveling are necessary, followed by digging pits of 60 x 60 x 60 
+cm. These pits should be ϐilled with 10-15 kg of farmyard manure (FYM) and soil 
+before planting. Spacing for G9 plants should be maintained at 1.8 m x 1.5 m or 2 m x 2 
+m, depending on the irrigation method and variety. Planting material should consist 
+of tissue-cultured plants or healthy sword suckers that are disease-free. Apply FYM 
+at 50 kg per plant per year. The recommended fertilizer dose per plant annually 
+includes 200-250 g of N, 60-80 g of P₂O₅, and 200-300 g of K₂O, applied in 4-5 splits, 
+with the ϐirst dose applied after planting and subsequent doses at two-month 
+intervals. Irrigation management should focus on water efϐiciency, ideally through 
+drip irrigation. 
+Banana
+FRUIT & VEGETABLE CROPS
+Finger Millet, Little Millet and Foxtail Millet 
+MILLETS 
+Millets are mostly rainfed, but supplemental irrigation may be necessary during 
+ϐlowering and grain ϐilling if rainfall is insufϐicient. For plant protection, control shoot 
+ϐly by applying Carbofuran at 10 kg/ha in furrows at sowing. To manage blast or leaf 
+spot diseases, spray Mancozeb at 2 g/L at the onset of symptoms. Crop rotation and 
+ϐield hygiene are also important practices for disease management. Harvesting 
+should occur when the grains are mature and hard, typically 90-110 days after 
+sowing, depending on the species. Ensure the grains are well-dried before threshing 
+and storage to prevent mold. Additionally, millets can be intercropped with pulses 
+such as green gram and black gram, or with oilseeds like sesame, to improve returns 
+and enhance soil fertility.
+55
+
+
+================ Page 80 ================
+Haryana & Delhi
+Fertilizer use: Apply 80-100 Kg N per ha for American Cotton and 50 kg N for desi 
+cotton along with 30 kg P₂O₅/ha. In case of hybrid cotton, 150 kg N, 60 kg P₂O₅, 60 kg 
+K₂O and 25 kg ZnSo₄ per ha has been recommended. Apply 1/3 dose of N, full dose of 
+P₂O₅, full dose of potash and full dose of ZnSo₄ at time of sowing. Remaining dose of N 
+should be applied in two equal splits at square formation and ϐlowering stage.  In 
+sandy soil the research results have revealed that 90 per cent dose of fertilizer 
+through soil application and 10 per cent through foliar spray at the boll development 
+stage gave the highest seed cotton yield. Inoculation of cotton seed with C2, M4 and 
+Azospirillum culture resulted into saving of 25-27 kg N/ha.
+Seed rate: Use 15-20 kg delinted seed of improved American cotton varieties for 
+sowing in one ha area. 12.5 kg of seed/ha is required for Desi cotton varieties. Seed 
+rate of 3-3.750 kg /ha is required for American cotton hybrids and desi cotton 
+hybrids. Seed rate of 2.125 kg/ha is required for Bt Cotton hybrids.
+Seed treatment and seed soaking: Before sowing, seed should be dipped in water 
+up to 5-6 hours for better germination. Treat the seed with 5 gm Emisan, 1 gm 
+streptocyclin and 1 gm succinic acid in 10 litres of water. In termite affected areas 
+treat the seed with 10 ml chlorpyriphos apart from above mentioned chemicals. Seed 
+treatment with carbendazim @ 2 gm/kg in the root rot affected areas is essential. 
+Seed treatment with Imidacloprid @ 7.5 gm/kg seed to escape the crops from 
+sucking pests up to 40-60 days.
+Mango
+Method of Sowing: Sow the crop in lines 67.5 cm apart with a cotton sowing drill or 
+cotton planter and plant to plant spacing of 60 cm or row to row spacing of 100cm 
+and plant to plant spacing of 45 cm. Sowing should be done at a depth of 4-5 cm.
+In horticultural crops at fruiting stage such as mango, while carrying out ϐield operations 
+related to nutrient sprays and crop protection adequate precautions in handling of inputs, 
+Varieties and hybrids: Improved American cotton varieties: HS-6, H-1117, H-1126, H-
+1098 Improved, H-1236, H-1300. Recommended improved hybrids- HHH-223, HHH-
+287. Desi Cotton varieties- HD-123, HD-324, HD-432. Desi Cotton hybrid - AAH-1 
+results in yield reduction. For all desi cotton varieties/hybrids, best sowing time is 
+mid-April to 1ƗƘ week of May. The mortality of seedling is very high during May & 
+June.
+Plant protection: Leaf sucking pest & Leaf Curl Virus disease: seed should be treated 
+with 4 g Thiamethaxom 70 WS/kg seed before sowing. Close monitoring on white ϐly 
+host plants like vegetables, ϐlower plants, weeds & unwanted plants. These host 
+plants must be uprooted & burnt from time to time. Some vegetables like Ladies 
+Finger, Brinjal, Tomato & Chilli also act as host plants for whiteϐly, accordingly, as per 
+need these must be sprayed with Thiamethaxom 25 WG @ 0.5g/litre water. Bacterial 
+blight: seed should be treated with soaking in 1 g Streptomycin or 10 g 
+Plantomycin/10 litre water before sowing. Spray Thiamethaxom 25 WG @ 100g/ha 
+and Profenophos 50 EC @1250 ml/ha for sucking pest. Proclaim (emamectin 
+benzoate) 5 SG @250g/ha for pink, spotted and American bollworm.
+FRUIT & VEGETABLE  CROPS
+65
+
+
+================ Page 90 ================
+Himachal Pradesh
+and blight diseases. Drip irrigation with mulching should be used for better crop 
+management and conservation of water. In Kharif tomato production system, 
+nursery raising may be started in the month of June and transplanting should be 
+completed by July. In areas where blossom end rot is a problem apply calcium 
+chloride @ 5g/ L of water as foliar application.
+For the management of early blight, buckeye rot and fruit rot diseases, apply copper 
+oxychloride @ 3g/ L, Ridomil MZ @ 2.5 g/L and Mancozeb 45 @ 2.5 g or Kavach @ 2g/ L 
+respectively as and when symptoms appear. For the management of fruit borer, apply 
+Profenophos @ 1ml/ L or Chlorpyriphos @2ml or Cypermethrin 10EC @ 1ml per litre of 
+water .
+Bell pepper 
+Cultural Practices along with Fertilizer application: Elite open pollinated varieties viz., 
+California Wonder, Solan Bharpur, Solan Shakti should be planted up to end of April to get 
+higher yields. Optimum spacing of 60 cm may be maintained between row to row and 45 
+cm between plant to plant while transplanting of open pollinated varieties or hybrids. 
+Apply total FYM (250q/ha), Single Super Phosphate (475kg/ha), Muriate of Potash 
+(90kg/ha) with half of Urea (200kg/ha) at the time of ϐield preparation. Remaining half of 
+urea should be applied in two equal split doses one after one month of sowing and 
+another before ϐlowering. Under protected conditions, capsicum (coloured/ green) can 
+be transplanted by May end. Apply FYM @ 120t/ha and NPK mixture @ 50kg/ ha before 
+transplanting. Urea 11g, SSP 30g and MOP 8.4g per square meter should also be applied to 
+get higher yield. Apply soluble fertilizers like Polyfeed (19:19:19) @150 kg/ha twice a 
+Demonstration of mulch with drip irrigation at  farmer's ϐields in  Solan disrict
+Demonstration on coloured bell 
+peppers under protected conditions
+Solan Shakti variety of bell pepper
+75
+
+
+================ Page 100 ================
+Jammu & Kashmir
+oxychloride 3 g/L or apply bleaching powder @ 10 kg/acre; for leaf blight, spray 
+propiconazole @ 0.1% at disease onset.
+Use 6-8 kg seed/acre; varieties include Pant U-19, Uttara, Pant U-31, NDU 99-3, KUG 
+479; spray chlorpyriphos 20EC @ 2 ml/litre or imidacloprid 17.8 SL @ 0.3 ml/litre to 
+manage hairy caterpillar and whiteϐly.
+Use 800 g-1 kg seed/acre in July; for pests like hairy caterpillars and whiteϐly, spray 
+chlorpyriphos 20EC @ 2 ml/litre or imidacloprid 17.8 SL @ 0.3 ml/litre.
+Intercropped with maize (row spacing 75 × 20 cm); sow 9.5 kg seed/acre; treat with 
+copper oxychloride @ 3g/kg; control aphids and anthracnose with chlorothalonil @ 
+2 g/L spray.
+Mash (Black Gram)
+Use 6-8 kg seed/acre; varieties include Pant Mung-6, Pusa Vishal, SML 668, Pusa 
+0672, Satya; manage YMV and sucking pests with resistant varieties and spray 
+dimethoate 30 EC @ 1 ml/litre or thiamethoxam @ 0.03%.
+Hybrid Jowar (Sorghum)
+Rajmash (Bhaderwah Local/Chinta Selection)
+FODDER CROPS
+Use 2 kg of hybrid seed/acre, apply 40:24:10 kg NPK/acre, and manage pests like leaf 
+caterpillars and weevils with chlorpyriphos 1.5% D @ 10 kg/acre.
+OILSEED CROPS
+Sesame (Til)
+PULSE CROPS 
+Moong (Green Gram)
+COMMERCIAL CROPS 
+Bajra (Pearl Millet)
+Sow 5 kg seed/acre with 20:12:6 kg NPK; for insect pests like shoot ϐly and stem 
+borer, apply cartap hydrochloride 4G @ 8 kg/acre in central whorls at 10-20 DAS.
+Sugarcane
+Saffron requires 20-24 q corms/acre, with fertigation using 8 kg of Urea, 24 kg of DAP, 
+and 13 kg of MOP, and management involves deep ploughing, raised beds, disease-
+free corms, and rodent control.
+Saffron
+Bajra and Jowar are important kharif fodder crops, with varieties like Giant Bajra, 
+FBC-16, PCB 164 for Bajra, and MP Chari, Haryana Chari-260, Proagro Chari (SSG-
+998) for Jowar, suitable for both irrigated and rainfed conditions.
+Grown in parts of Jammu and Kathua, high-yielding sugarcane varieties like COJ-64, 
+COJ-81, and CO-1148 are preferred. Manage termites with chlorpyriphos, borers 
+with cartap, and diseases like red rot and grassy shoot using resistant varieties and 
+appropriate sprays.
+85
+
+

data/extracted/inspect_rabi.txt

@@ -0,0 +1,487 @@
+Total Pages: 755
+
+================ Page 5 ================
+o”kZ 2022 rd Ñ”kdksa dh vk; dks nksxquh djus ds egRodka{kh 
+y{; dh izkfIr ds fy;s Ñf”k {ks= esa izlaLdj.k] Hk.Mkj.k] Ñf”kd 
+mRiknu laxBuksa dk xBu dk xBu ,oa ,xzh bUÝkLVªDpj Q.M dh 
+?kks”k.kk vkRefuHkZj Hkkjr fe’ku ds varxZr dh xbZ gSA blls vxys dqN 
+o”kks± esa Ñf”k dks csgrj xfr iznku dh tk ldsxhA
+Hkkjrh; Ñf”k vuqla/kku ifj”kn us dksfoM egkekjh ls mRiUu 
+pqukSfr;ksa dks xaHkhjrk ls ysrs gq, ykWdMkmu ls izHkkfor fdlkuksa dks 
+bl eqf’dy le; esa gj laHko O;ogkfjd lek/kku o lq>ko miyC/k 
+djkus esa lfØ; Hkwfedk fuHkkbZ gSA fu/kkZfjr y{;ksa dh izkfIr ds fy, 
+Hkkjrh; Ñf”k vuqla/kku ifj”kn ,oa jk”Vªh; Ñf”k vuqla/kku iz.kkyh 
+ds vU; ?kVdksa dk ;ksxnku vfregRoiw.kZ gSA blh ifjizs{; esa jch 
+2021&22 ds fy, Hkkjrh; Ñf”k vuqla/kku ifj”kn }kjk Ñf”k o vU; 
+fo/kkvksa ij vk/kkfjr lykg ¼,Mokbtjh½ fodflr dj Ñ”kdksa dks lgh 
+le; esa miyC/k djkus dk ;g iz;kl ljkguh, gSA eq>s iw.kZ fo’okl 
+gS fd fdlkuksa ds fy, ;g tkudkjh dkQh mi;qDr ,oa ykHkdkjh 
+gksxh vkSj mUgsa blls Ñf”k ds {ks= esa mfpr ykHk izkfIr ds lkFk gh 
+lkFk mudh vkenuh nksxquh djus esa enn feysxhA
+
+
+================ Page 10 ================
+xi
+PRefACe
+The COVID-19 Pandemic has created unprecedented situation 
+throughout the world. It has been more than a year and half since 
+COVID-19 Pandemic threatened the human life by killing millions 
+across the globe. During this crisis the economies of countries suffered 
+heavily but agriculture sector showed lot of resilience. Growth of 
+agriculture sector was not thwarted in India and it continued to set 
+records of food grains production. Krishi Vigyan Kendras (KVKs), in 
+tune with the policy directions and guidelines of Government of India 
+and Indian Council of Agricultural Research (ICAR), reached farmers 
+across the nation using Information and Communication Technology 
+to issue farm advisories. KVKs also provided necessary input support 
+by making available seeds and planting materials and agro advisories for 
+farmers in regional languages. 
+The Agricultural Technology Application Research Institutes 
+(ATARIs) throughout India, collaborated with Research Institutes 
+and State Agricultural Universities, State Agriculture and other Line 
+Departments to develop Rabi advisories for the benefit of farming 
+community across the country. The advisories include scientifically 
+proven best practices related to crops, horticulture, livestock and 
+fisheries to be followed by the farmers to obtain optimum production 
+levels with maximum profit during Rabi season 2021-22. 
+I am very hopeful that these advisories will help farmers and 
+farmers’ groups in appropriate decision making in maximizing yields 
+and enhancing farm income. I congratulate the team for bringing out 
+such important compilation in real time frame for benefit of farming 
+community of country.
+(A. K. Singh)
+Deputy Director General (Agricultural Extension)
+ICAR, New Delhi
+
+
+================ Page 20 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+10
+advised to the farmers. For chickpea use of high yielding and pest 
+tolerant varieties JG 14, JG 11, JG 130, JG 16, JAKI 92-18, JG 63, JG 
+412, JG 226, JG 36, PBG 1, BG 267, GNG146, RVG 201, RVG 202, 
+JGK 1, JGK 2, JGK 3, KAK 2, GG-1 (Gujarat Gram-1), Vaibhav, 
+JG-14, Indira Chana-1, JSC-55, JSC-56, BGD-128 (Pusa Shubhra), 
+IPCK-2002-29, IPCK-2004-29, IPC-2066-77 and JGG 1 has been 
+advised. For better yield and returns from Lentil cultivation of 
+improved varieties Lens-4076, IPL-81 (Noori), JL-3, IPL-316, RVL 
+11-6, L-4717 (Pusa Ageti Masoor), RKL 14-20 (Kota Masoor-2), 
+L-4727, Kota Masoor-1 (RKL-607-1), and Chhattisgarh Masoor-1 
+is advised. For more returns from Linseed cultivation, sowing of 
+high yielding multiple resistant varieties viz., JLS 66, JLS 73, JLS 95, 
+RLC 148, RLC 164, JLS 79, R-552, Kiran, T-397, Padmini, Shekhar, 
+Indira Alsi-32, Kartika, Deepika, Indravati Alsi, RLC-133, RLC-
+143, RLC-153 and RLC 167 is advised. Sowing of mustard varieties 
+Pusa Tarak, Pusa Mahak, Pusa Agrani, Pusa Jai Kisan (BW-902), 
+Pusa Bold, Kranti (PR-15), Vardan (RK 1467), Varuna (T-59), 
+Chhattisgarh Sarson-1, Indira Toria-1 and Pusa Aditya are advised. 
+High yielding and high sugar varieties viz. CoJN 86-600, CoJN 
+86-141, CoJN 9505, COC 671, Co 94008 (Shyama), CoM 88121 
+(Krishna), Co 86032 (Nayana) of sugarcane is recommended for 
+cultivation. 
+ 
+Farmers are advised to follow improved practices for cultivation of 
+fruits (mango, guava, pomegranate, ber) and vegetable (Tomato, 
+Cauliflower, Cabbage, Onion, Vegetable Pea, Chilli, Potato) crops 
+during Rabi season.
+ 
+Advisory for management of Animal Husbandry enterprises viz. 
+dairy, poultry, fisheries, and sheep & goat during Rabi season is 
+also given to the farmers of the zone. 
+ 
+In Zone-X (Andhra Pradesh, Telangana, Tamil Nadu & 
+Pondicherry) Rice, maize, green gram, black gram, bengal 
+gram, groundnut, sesame, and sugarcane are major crops. The 
+major improved varieties of rice advised for cultivation during 
+
+
+================ Page 30 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+21
+Fruit crops 
+Apple
+ 
+Prepare tree basins and apply recommended dose of FYM (100 kg/
+plant), Nitrogen (1.5 kg Urea per tree basin), Phosphorous (SSP 
+2 kg per plant) and potash (MOP 1.7 kg per plant) for plants of 
+age more than 10 years. Complete dose of Potash and phosphorous 
+should be given at the Time of basin preparation along with FYM 
+during December- January.
+ 
+Half dose of Nitrogen (750 g per tree) should be given 2-3 weeks 
+before flowering and remaining quantity (750 g per tree) should be 
+applied after one month.  
+ 
+The fallen leaves of apple should be collected and decomposed in a 
+compost pit or spray of 5% urea (10 kg in 200lt water) may be done 
+on orchard floor on fallen leaves to ensure fast decomposition of 
+infected leaves. 
+ 
+During winters (November- December), expose the root system 
+of infected trees and cut the infected portion and apply Bordeaux 
+paint / chaubatia paste for the control of White root rot. 
+ 
+Remove all dead, diseased braches at the time of pruning and apply 
+Bordeaux paint/ chaubatia paste or any other Copper fungicide-
+based paint.
+ 
+Scarify wounds near collar region and apply Bordeaux paint/ 
+chaubatia paste or any other Copper fungicide-based paint during 
+winter season. 
+ 
+For the management of canker, scarify the diseased portion upto 
+healthy region and apply Bordeaux paint/ chaubatia paste or any 
+other Copper fungicide-based paint during winter season. 
+ 
+Apply a mixture of lime + copper sulphate + linseed oil (30kg lime+ 
+500 gm copper sulphate + 500 ml linseed oil in 100 L water) on 
+stems upto a height of 2-3 ft from the ground level during October- 
+November for protection against sun burning. 
+
+
+================ Page 40 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+31
+ 
+Harvesting and Threshing: Harvest the crop when siliquae turn 
+yellow.
+Sugarcane
+Improved varieties-
+ 
+Early Maturing Varieties: CoPb 92, Co 118, CoJ 85 and CoJ 64
+ 
+Mid-Late Maturing Varieties: CoPb 93, CoPb 94, Co 238, CoPb 
+91 and CoJ 88
+Time of Planting
+ 
+Mid-February to the end of March is the optimum time for planting 
+sugarcane in the Punjab. Do not plant early maturing varieties after 
+March. Avoid late planting. 
+Seed Selection
+ 
+The seed should be free from red-rot, wilt, smut, ratoon-stunting 
+and grassy shoot diseases. Use only the top two-third portion of 
+the selected canes for planting.
+Seed Rate
+ 
+Use 20 thousand three-budded setts or 15 thousand four-budded 
+sets or 12 thousand five-budded setts per acre. In other words, 30-
+35 quintal of seed is required for sowing one acre. Due to thick 
+canes, seed rate of Co 118 and CoJ 85 should be kept about 10% 
+higher (on weight basis).
+Seed Treatment
+ 
+To improve germination, soak the setts in ethrel solution 
+overnight by dissolving 25 ml of Ethrel 39 SL in 100 liters of water. 
+Alternatively, soak the setts in water for 24 hours before planting.
+Spacing and Planting Techniques
+ 
+Trench Planting: Plant crop in rows 75 cm apart and 20-25 cm 
+deep trenches. After placing the setts in trenches, cover the setts 
+
+
+================ Page 50 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+41
+water and isolate them in the calving pen about 10 days before 
+calving.
+ 
+After calving, wipe clean the piglets with a clean cloth and assist 
+them to suckle the colostrum.
+ 
+Install a light bulb about two feet high to keep children warm.
+ 
+Cut the needle teeth within two days before birth and giveiron 
+supplementation on the third and thirteenth day to deal with 
+anaemia. Start giving solid food in the second week.
+March
+ 
+Wean the piglets 45-60 days after calving and start giving a solid 
+diet with 20-22% raw protein.
+ 
+Sell male children who are sold by 15 days of age
+Poultry farming
+October
+ 
+Assess the cleanliness and biosecurity of the entire farm.
+ 
+Restrict workers/ visitors entering the shed unnecessarily.
+November
+ 
+Continue the work for the month of October
+ 
+Take measures to maintain the temperature and humidity inside 
+the shed according to the changing weather. Check electrical 
+appliances, light blowers, etc. inside the shed.
+December
+ 
+Continue with the chores of the month of October-November.
+ 
+Keep the chicks under the brooder. Use plastic curtains, heaters, or 
+heaters to keep the temperature constant in the shed.
+ 
+Include appropriate medicine/coccidiostats in the diet to prevent 
+coccidiosis/ bloody diarrhea.
+ 
+Add partially dried berseem to the diet of poultry birds.
+
+
+================ Page 60 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+51
+Radish
+ 
+Varieties: Japanese White, Minowase, Pusa Chetki, Pusa Himani, 
+Pusa Reshmi, White Icicle, Pusa Desi, Arka Nishant
+ 
+Seed rate is 4-4.8 kg/acre for Asiatic types, 6-7.2 kg/acre for 
+European types and 1.6-2.0 kg/acre with Dibbling Method.
+ 
+24:12:20 kg/acre of NPK is recommended dose of fertilizers. Apply 
+12 t/acre of FYM together with P2O5 and K2O and half of N at the 
+time of field preparation. Remaining half N should be applied at 
+the time of earthing-up.
+Carrot
+ 
+The optimum temperature for growth is 16-18°C and colour 
+development in 20-22°C. 
+ 
+Varieties: Pusa Kesar, Nantes, Chaman, PusaYamdagini
+ 
+Seeds may be soaked in water for 12-24 hours prior to sowing to 
+improve germination
+ 
+24:12:20 kg/acre of NPK is recommended dose of fertilizers. Apply 
+12 t/acre of FYM together with P2O5 and K2O and half of N at the 
+time of field preparation. Remaining half N should be applied at 
+the time of earthing up.
+Garlic
+ 
+It requires cool and moist period during growth and relatively dry 
+period during maturity
+ 
+Varieties: Agrifound Parvati-2 (G-408), Yamuna Safed (G-1):
+ 
+Planting Time in Sub Tropical areas is September- October; in 
+Intermediate (low) is August -September and Intermediate (High) 
+is March-April.
+ 
+Seed rate is 2.0-2.4 q/acre (Cloves) with Spacing 15 cm x 7.5 cm 
+and 40:20:20 NPK & 8 t/acre of FYM.
+ 
+The weeds in garlic can be initially controlled by the application of 
+pendimelhalin @ 0.8-1.0 litres in 250 litres of water or 1.2- 1.6ml/
+
+
+================ Page 70 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+61
+iodine test and starch rating should be from 2.00 to 2.5 on 1- 6 
+rating scale for prolonged storage.
+ 
+In Apples, fruit firmness test should be done with the help of 
+pressure tester and fruit pressure should range between 15 to 17 
+lbs/ sq inch.
+ 
+Remove twigs infested with WAA and apply Chaubatia paste on 
+cut areas for Woolly apple aphid.
+Apple fruit borer: 
+ 
+Maintain good sanitation in the infested orchards, all the dropped 
+and infested fruits of apple should be collected and buried deep in 
+the soil. 
+ 
+Burlapping practice should be followed, and the overwintering 
+stages should be destroyed along with the burlap.
+Apple stem borer: 
+ 
+Heavily infested branches, twigs and completely dried trees should 
+be uprooted, removed from the orchard, and destroyed.
+ 
+Insertion of petrol-soaked cotton deep in the holes of apple tree, 
+followed by plastering with mud containing insecticide dust/ WP 
+10% in 6:1 ratio. OR
+ 
+Pressurized injection of Petrol in the holes, followed by plastering 
+as mentioned above.
+San Jose scale & Woolly apple aphid
+ 
+Remove twigs infested with SJS and WAA during pruning and 
+dispose them away from the orchard. Apply Chaubatia paste on 
+cut areas.
+European red mite
+ 
+If the population is more than 20 mites per leaf, spray Fenazaquin 
+10 EC (40ml) per 100 litres of water.
+
+
+================ Page 80 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+71
+Goat & Sheep
+Disease
+Symptoms
+Prevention
+Bacterial Disease
+Haemorrhagic 
+Septicemia
+Fever, dysentery, swelling 
+of lower mandible and 
+death more occurred.
+Vaccinate first dose at 3-4 month 
+of age and booster at 3-4 week after 
+first dose. Repeat at every 6/12 
+months interval in sep/oct.
+Brucellosis
+Abortion during late 
+pregnancy, infertility, 
+scrotal swelling in male, 
+joint swelling
+Disposal of dead foetus and 
+placenta. Use gloves while handling 
+infected items as it affects human 
+beings.
+Pneumonia
+Fever, respiratory distress, 
+mucous discharge from 
+nostril, reduced feed intake 
+and weight gain, cough
+Clean water, well ventilated house.
+Enterotoxaemia
+Sudden death in young 
+growing kids. Mucous 
+diarrhoea may also seen 
+during death
+Vaccinate first dose at 3-4 month of 
+age, booster at 3-4 weeks after first 
+dose. Repeat every 6/12 months 
+interval.
+Collibacillinum 
+Diarrhoea, Sudden Death, 
+reduce feed intake, usually 
+occur in young ones
+Clean and disinfect the lamb/kid 
+shelter. Provide clean water
+Viral Disease
+Peste Des Petits 
+Ruminants 
+(PPR)
+Fever, Occular and nasal 
+mucous discharge, mouth 
+lesion, respiratory distress
+First dose at 3 month of age and 
+repeat every 3 years. 
+Separation of infected one from 
+healthy animals.
+Foot and 
+Mouth Disease
+Fever, wound lesion in 
+foot and mouth, excess 
+salivary secretion, difficult 
+in walking
+First vaccination at 3-4 month and 
+Booster 3-4 week after fist dose. 
+Repeat every 6/12 months interval 
+in Oct and April
+Contagious 
+Ecthyma 
+(Khalay)
+Postules, Scrab formation, 
+Extension Lession around 
+Mouth slips.  Anorexia and 
+starvation. Kids are more 
+susceptible to the disease
+Wash with 1% potassium 
+Permagnate solution. Apply tincture 
+iodine followed by glycerine. Isolate 
+the affected animals from other 
+healthy animals
+
+
+================ Page 90 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+81
+ 
+Varieties for hill areas Marsid, Nanperil, IXL, Ne-plus-altra, Texas
+Fish and Pond Maintenance during Winter Season
+ 
+Fish, being a cold-blooded aquatic animal, needs special care 
+during winters. As temperature of the surface water is colder than 
+the bottom layers, the fish prefers to live in the bottom zone. Famers 
+shall keep the water depth up to 6 feet, so that it gets enough space 
+for hibernating in the warmer bottom zone. In shallow waters, the 
+whole water column becomes cold, which affects the fish and can 
+prove fatal.
+ 
+As day length and light intensity also decreases during winters, 
+oxygen levels decline in ponds due to reduced photosynthetic 
+activity. The situation further aggravates during continuous cloudy 
+days. The farmers are advised to aerate their ponds either by adding 
+fresh water or by using aerators, especially during early hours of 
+the day.
+ 
+Feed intake of fish decreases with decrease in temperature as its 
+digestive system becomes sluggish. Hence, it is essential to reduce 
+the feeding rate by 50-70 % depending on the temperature.
+ 
+In case the temperature falls below 50 degrees, it is advice to stop 
+feeding. Excess feed remains unconsumed and accumulates at the 
+pond bottom, which deteriorates the water quality.
+ 
+Farmers re further advised to use low protein diets. It is also 
+necessary to reduce/stop adding organic manures such as cow 
+dung, poultry droppings, and pig dung in the pond as rate of 
+decomposition of organic manures declines due to poor microbial 
+activity during winters. It is also advised to go for periodic raking of 
+bottom soil (with the help of barbed wire) to prevent any suspected 
+accumulation of toxic gases at the pond bottom.
+Animal care during winter season
+ 
+Feed more roughages (like hay, straws. etc.) or forages (berseem) to 
+maintain the milk production and body heat of the dairy animals.
+
+
+================ Page 100 ================
+ICAR RABI AgRo-AdvIsoRy foR fARmeRs
+91
+Other activities to be performed: 
+ 
+To achieve higher water use efficiency (WUE) of available irrigation 
+water, especially in canal area, land should be levelled with Laser 
+Land Leveller before sowing of Rabi season crops.
+ 
+Collect, Harvest & Conserve maximum rainwater as much as 
+possible in Farm Pond or Plastic based water pond and minimize 
+the losses of conserved rainwater for life saving irrigation on 
+different critical stages during moisture deficit conditions, to 
+achieve higher productivity level. 
+ 
+As per availability of resources, prepare proper work plan for 
+sustainable farming/ organic farming/ Paramparagat Krishi in 
+Rabi season and for this nearby KVK may help you in providing 
+proper advisory and guidance.
+ 
+Adopt appropriate IFS Models as per availability of different 
+resources, infrastructure, and facilities on their farm.
+ 
+Eligible farmers register themselves for Pradhanmantri Fasal 
+Bima Yojna (PMFBY) benefits, to minimize the risk from natural 
+calamities.
+Horticultural Crops
+Fruit crops
+Ber
+ 
+Recommended varieties: Seb, Gola, Umran, Ilaichi, Kaithali, 
+Mundiya
+ 
+General Management of orchard: 
+ 
+Orchard should be clean and weed free. 
+ 
+To get higher fruit yield it is recommended to place two 
+honeybee colonies or hive/Acre in September month for 
+better pollination because honey bees play important role in 
+pollination. Irrigation should be applied regularly at 10-15 
+days’ interval. 
+
+

data/quarantine/failed_advisories.json

@@ -0,0 +1,138 @@
+[
+  {
+    "season": "Kharif",
+    "source": "ICAR.pdf",
+    "state": "Assam",
+    "category": "Oilseed Crops",
+    "crop": "Maize",
+    "page": 42,
+    "content": "Maize Variety Bio 9544",
+    "validation_errors": [
+      "Content too short (22 chars)"
+    ]
+  },
+  {
+    "season": "Kharif",
+    "source": "ICAR.pdf",
+    "state": "Gujarat",
+    "category": "Poultry",
+    "crop": "Groundnut",
+    "page": 65,
+    "content": "SOUTH SAURASHTRA",
+    "validation_errors": [
+      "Content too short (16 chars)"
+    ]
+  },
+  {
+    "season": "Kharif",
+    "source": "ICAR.pdf",
+    "state": "Gujarat",
+    "category": "Poultry",
+    "crop": "Soybean",
+    "page": 66,
+    "content": "Cotton (Bt & Desi) Groundnut Demo Plot",
+    "validation_errors": [
+      "Content too short (38 chars)"
+    ]
+  },
+  {
+    "season": "Kharif",
+    "source": "ICAR.pdf",
+    "state": "Gujarat",
+    "category": "Fruit & Vegetable Crops",
+    "crop": "Banana",
+    "page": 71,
+    "content": "Finger Millet, Little Millet and Foxtail Millet",
+    "validation_errors": [
+      "Content too short (47 chars)"
+    ]
+  },
+  {
+    "season": "Kharif",
+    "source": "ICAR.pdf",
+    "state": "Maharashtra",
+    "category": "Fruit Crops",
+    "crop": "Pomegranate",
+    "page": 172,
+    "content": "Fruit cover in Pomegranate",
+    "validation_errors": [
+      "Content too short (26 chars)"
+    ]
+  },
+  {
+    "season": "Kharif",
+    "source": "ICAR.pdf",
+    "state": "Manipur",
+    "category": "Cereal Crops",
+    "crop": "Maize",
+    "page": 184,
+    "content": "Varietal demonstration in paddy",
+    "validation_errors": [
+      "Content too short (31 chars)"
+    ]
+  },
+  {
+    "season": "Kharif",
+    "source": "ICAR.pdf",
+    "state": "Mizoram",
+    "category": "Vegetable Crops",
+    "crop": "Pumpkin",
+    "page": 191,
+    "content": "Carrot",
+    "validation_errors": [
+      "Content too short (6 chars)"
+    ]
+  },
+  {
+    "season": "Rabi",
+    "source": "Rabi-Agro-Advisory-2021-22.pdf",
+    "state": "Mizoram",
+    "category": "Rabi Crops",
+    "crop": "Ginger",
+    "page": 298,
+    "content": "25 g Aniseed 15 g",
+    "zone": "Zone-Vii",
+    "validation_errors": [
+      "Content too short (17 chars)"
+    ]
+  },
+  {
+    "season": "Rabi",
+    "source": "Rabi-Agro-Advisory-2021-22.pdf",
+    "state": "Mizoram",
+    "category": "Rabi Crops",
+    "crop": "Onion",
+    "page": 298,
+    "content": "50 g Clove 6 nos.",
+    "zone": "Zone-Vii",
+    "validation_errors": [
+      "Content too short (17 chars)"
+    ]
+  },
+  {
+    "season": "Rabi",
+    "source": "Rabi-Agro-Advisory-2021-22.pdf",
+    "state": "Mizoram",
+    "category": "Rabi Crops",
+    "crop": "Garlic",
+    "page": 298,
+    "content": "10 g Tamarind pulp 50 g Red chilli 15 g",
+    "zone": "Zone-Vii",
+    "validation_errors": [
+      "Content too short (39 chars)"
+    ]
+  },
+  {
+    "season": "Rabi",
+    "source": "Rabi-Agro-Advisory-2021-22.pdf",
+    "state": "Mizoram",
+    "category": "Rabi Crops",
+    "crop": "Mustard",
+    "page": 298,
+    "content": "50 g",
+    "zone": "Zone-Vii",
+    "validation_errors": [
+      "Content too short (4 chars)"
+    ]
+  }
+]

pipeline/02_parse.py

@@ -0,0 +1,290 @@
+import json
+import re
+from pathlib import Path
+
+# Paths
+BASE_DIR = Path(__file__).resolve().parent.parent
+EXTRACTED_DIR = BASE_DIR / "data" / "extracted"
+PARSED_DIR = BASE_DIR / "data" / "parsed"
+CONFIG_DIR = BASE_DIR / "config"
+
+PARSED_DIR.mkdir(parents=True, exist_ok=True)
+
+# Load Canonical Lists
+with open(CONFIG_DIR / "crops.json", "r", encoding="utf-8") as f:
+    CANONICAL_CROPS = json.load(f)
+
+with open(CONFIG_DIR / "states.json", "r", encoding="utf-8") as f:
+    CANONICAL_STATES = json.load(f)
+
+# Helper to normalize ligatures and spaces
+def clean_text(text: str) -> str:
+    text = text.replace("\u00ad", "")  # soft hyphen
+    text = text.replace("\ufb01", "fi").replace("ϐ", "fi").replace("ϐield", "field")
+    text = text.replace("\ufb02", "fl")
+    text = text.replace("ff", "ff").replace("fi", "fi").replace("fl", "fl")
+    
+    # Remove repeated headers/footers
+    text = re.sub(r"(ICAR\s+KHARIF\s+AGRO-ADVISORY|ICAR\s+RABI\s+AgRo-AdvIsoRy\s+foR\s+fARmeRs|AgRo-AdvIsoRy\s+foR\s+fARmeRs)", "", text, flags=re.I)
+    
+    # Remove line numbers or solitary numbers (page numbers) at start/end of lines
+    lines = []
+    for line in text.split("\n"):
+        line_strip = line.strip()
+        # Skip solitary page numbers
+        if line_strip.isdigit():
+            continue
+        # Skip empty lines
+        if not line_strip:
+            continue
+        lines.append(line)
+    
+    return "\n".join(lines)
+
+# Check if line matches a state
+def detect_state(line: str) -> str:
+    line_clean = line.strip().lower().replace("&", "and").replace(",", "")
+    for state in CANONICAL_STATES:
+        state_clean = state.lower().replace("&", "and").replace(",", "")
+        # Match exact line or boundary
+        if line_clean == state_clean or line_clean.startswith(state_clean + " "):
+            return state
+    return None
+
+# Check if line matches a crop
+def detect_crop(line: str) -> str:
+    line_clean = line.strip().rstrip(":").strip().lower()
+    
+    # Handle direct exact matches
+    for crop in CANONICAL_CROPS:
+        if line_clean == crop.lower():
+            return crop
+            
+    # Handle composite crop names, e.g. "Mash (Black Gram)" matching black gram
+    for crop in CANONICAL_CROPS:
+        crop_clean = crop.lower()
+        if "(" in crop_clean:
+            # Extract name and bracketed parts
+            parts = re.findall(r'\b[a-z\s]+\b', crop_clean)
+            for part in parts:
+                part = part.strip()
+                if len(part) > 3 and line_clean == part:
+                    return crop
+                    
+    # Handle common sub-crop titles
+    if line_clean == "paddy":
+        return "Paddy"
+    if line_clean == "moong" or line_clean == "moong (green gram)":
+        return "Moong"
+    if line_clean == "urad" or line_clean == "black gram":
+        return "Black gram"
+        
+    return None
+
+# Categories
+CATEGORIES = [
+    "CEREAL CROPS", "PULSES", "OILSEEDS", "FRUIT AND VEGETABLE CROPS", 
+    "FRUIT & VEGETABLE CROPS", "VEGETABLE CROPS", "FRUIT CROPS", 
+    "ROOT AND TUBER CROPS", "LIVESTOCK", "POULTRY", "FISHERIES", 
+    "COMMERCIAL CROPS", "FODDER CROPS", "PULSE CROPS", "OILSEED CROPS"
+]
+
+def detect_category(line: str) -> str:
+    line_clean = line.strip().upper()
+    for cat in CATEGORIES:
+        if line_clean == cat:
+            return cat.title()
+    return None
+
+def parse_kharif():
+    print("Parsing Kharif advisories...")
+    input_file = EXTRACTED_DIR / "ICAR.json"
+    if not input_file.exists():
+        print(f"Extraction file {input_file} not found!")
+        return []
+
+    with open(input_file, "r", encoding="utf-8") as f:
+        pages = json.load(f)
+
+    records = []
+    current_state = None
+    current_category = None
+    current_crop = None
+    buffer = []
+    current_page = None
+
+    for page_data in pages:
+        page_no = page_data["page"]
+        text = clean_text(page_data["text"])
+        lines = text.split("\n")
+
+        for line in lines:
+            line_strip = line.strip()
+            if not line_strip:
+                continue
+
+            # Detect state change
+            state = detect_state(line_strip)
+            if state:
+                # Save previous crop if exists
+                if current_crop and buffer:
+                    records.append({
+                        "season": "Kharif",
+                        "source": "ICAR.pdf",
+                        "state": current_state,
+                        "category": current_category,
+                        "crop": current_crop,
+                        "page": current_page,
+                        "content": " ".join(buffer)
+                    })
+                    buffer = []
+                current_state = state
+                current_crop = None
+                continue
+
+            # Detect category change
+            category = detect_category(line_strip)
+            if category:
+                current_category = category
+                continue
+
+            # Detect crop change
+            crop = detect_crop(line_strip)
+            if crop:
+                if current_crop and buffer:
+                    records.append({
+                        "season": "Kharif",
+                        "source": "ICAR.pdf",
+                        "state": current_state,
+                        "category": current_category,
+                        "crop": current_crop,
+                        "page": current_page,
+                        "content": " ".join(buffer)
+                    })
+                    buffer = []
+                current_crop = crop
+                current_page = page_no
+                continue
+
+            # Accumulate content if inside a crop
+            if current_crop:
+                buffer.append(line_strip)
+
+    # Save last crop
+    if current_crop and buffer:
+        records.append({
+            "season": "Kharif",
+            "source": "ICAR.pdf",
+            "state": current_state,
+            "category": current_category,
+            "crop": current_crop,
+            "page": current_page,
+            "content": " ".join(buffer)
+        })
+
+    return records
+
+def parse_rabi():
+    print("Parsing Rabi advisories...")
+    input_file = EXTRACTED_DIR / "Rabi-Agro-Advisory-2021-22.json"
+    if not input_file.exists():
+        print(f"Extraction file {input_file} not found!")
+        return []
+
+    with open(input_file, "r", encoding="utf-8") as f:
+        pages = json.load(f)
+
+    records = []
+    current_zone = None
+    current_state = None
+    current_crop = None
+    buffer = []
+    current_page = None
+
+    for page_data in pages:
+        page_no = page_data["page"]
+        text = clean_text(page_data["text"])
+        lines = text.split("\n")
+
+        for line in lines:
+            line_strip = line.strip()
+            if not line_strip:
+                continue
+
+            # Detect zone pattern, e.g. "Zone-III" or "Zone III"
+            zone_match = re.search(r'\b(Zone-\w+|\bZone\s+\w+)\b', line_strip, re.I)
+            if zone_match:
+                current_zone = zone_match.group(1).title()
+
+            # Detect state mention
+            state = detect_state(line_strip)
+            if state:
+                if current_crop and buffer:
+                    records.append({
+                        "season": "Rabi",
+                        "source": "Rabi-Agro-Advisory-2021-22.pdf",
+                        "state": current_state,
+                        "category": "Rabi Crops",
+                        "crop": current_crop,
+                        "page": current_page,
+                        "content": " ".join(buffer),
+                        "zone": current_zone
+                    })
+                    buffer = []
+                current_state = state
+                current_crop = None
+                continue
+
+            # Detect crop change
+            crop = detect_crop(line_strip)
+            if crop:
+                if current_crop and buffer:
+                    records.append({
+                        "season": "Rabi",
+                        "source": "Rabi-Agro-Advisory-2021-22.pdf",
+                        "state": current_state,
+                        "category": "Rabi Crops",
+                        "crop": current_crop,
+                        "page": current_page,
+                        "content": " ".join(buffer),
+                        "zone": current_zone
+                    })
+                    buffer = []
+                current_crop = crop
+                current_page = page_no
+                continue
+
+            # Accumulate content
+            if current_crop:
+                buffer.append(line_strip)
+
+    # Save last crop
+    if current_crop and buffer:
+        records.append({
+            "season": "Rabi",
+            "source": "Rabi-Agro-Advisory-2021-22.pdf",
+            "state": current_state,
+            "category": "Rabi Crops",
+            "crop": current_crop,
+            "page": current_page,
+            "content": " ".join(buffer),
+            "zone": current_zone
+        })
+
+    return records
+
+def main():
+    kharif_records = parse_kharif()
+    rabi_records = parse_rabi()
+    
+    all_records = kharif_records + rabi_records
+    
+    output_file = PARSED_DIR / "advisories.json"
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(all_records, f, indent=2, ensure_ascii=False)
+        
+    print(f"Successfully compiled {len(all_records)} raw records.")
+    print(f"Saved to {output_file}")
+
+if __name__ == "__main__":
+    main()

pipeline/03_validate.py

@@ -0,0 +1,94 @@
+import json
+import hashlib
+from pathlib import Path
+
+# Paths
+BASE_DIR = Path(__file__).resolve().parent.parent
+PARSED_DIR = BASE_DIR / "data" / "parsed"
+QUARANTINE_DIR = BASE_DIR / "data" / "quarantine"
+CONFIG_DIR = BASE_DIR / "config"
+
+QUARANTINE_DIR.mkdir(parents=True, exist_ok=True)
+
+# Load Canonical Lists
+with open(CONFIG_DIR / "crops.json", "r", encoding="utf-8") as f:
+    CANONICAL_CROPS = set(crop.lower() for crop in json.load(f))
+
+with open(CONFIG_DIR / "states.json", "r", encoding="utf-8") as f:
+    CANONICAL_STATES = set(state.lower() for state in json.load(f))
+
+def main():
+    input_file = PARSED_DIR / "advisories.json"
+    if not input_file.exists():
+        print(f"Parsed advisories file {input_file} not found!")
+        return
+        
+    with open(input_file, "r", encoding="utf-8") as f:
+        records = json.load(f)
+        
+    valid_records = []
+    quarantined_records = []
+    seen_hashes = set()
+    
+    for r in records:
+        state = r.get("state")
+        crop = r.get("crop")
+        season = r.get("season")
+        content = r.get("content", "").strip()
+        
+        errors = []
+        
+        if not state:
+            errors.append("Missing state")
+        elif state.lower() not in CANONICAL_STATES:
+            errors.append(f"State '{state}' is not in canonical list")
+            
+        if not crop:
+            errors.append("Missing crop")
+        elif crop.lower() not in CANONICAL_CROPS:
+            errors.append(f"Crop '{crop}' is not in canonical list")
+            
+        if not season:
+            errors.append("Missing season")
+            
+        if not content:
+            errors.append("Empty content")
+        elif len(content) < 50:
+            errors.append(f"Content too short ({len(content)} chars)")
+            
+        # Deduplication
+        if not errors:
+            # Generate SHA-256 hash
+            content_hash = hashlib.sha256(
+                f"{state.lower()}|{crop.lower()}|{season.lower()}|{content}".encode("utf-8")
+            ).hexdigest()
+            
+            if content_hash in seen_hashes:
+                errors.append("Duplicate advisory record")
+            else:
+                seen_hashes.add(content_hash)
+                
+        if errors:
+            r_failed = r.copy()
+            r_failed["validation_errors"] = errors
+            quarantined_records.append(r_failed)
+        else:
+            valid_records.append(r)
+            
+    # Save valid records
+    valid_output = PARSED_DIR / "valid_advisories.json"
+    with open(valid_output, "w", encoding="utf-8") as f:
+        json.dump(valid_records, f, indent=2, ensure_ascii=False)
+        
+    # Save quarantined records
+    quarantine_output = QUARANTINE_DIR / "failed_advisories.json"
+    with open(quarantine_output, "w", encoding="utf-8") as f:
+        json.dump(quarantined_records, f, indent=2, ensure_ascii=False)
+        
+    print(f"Validation summary:")
+    print(f"  Valid records: {len(valid_records)}")
+    print(f"  Quarantined records: {len(quarantined_records)}")
+    print(f"  Outputs saved to: {valid_output} and {quarantine_output}")
+
+if __name__ == "__main__":
+    main()

pipeline/04_chunk.py

@@ -0,0 +1,81 @@
+import json
+import tiktoken
+from pathlib import Path
+
+# Paths
+BASE_DIR = Path(__file__).resolve().parent.parent
+PARSED_DIR = BASE_DIR / "data" / "parsed"
+
+# Tokenizer
+TOKENIZER_NAME = "cl100k_base"  # Standard GPT-4/Gemini cl100k_base
+encoding = tiktoken.get_encoding(TOKENIZER_NAME)
+
+def count_tokens(text: str) -> int:
+    return len(encoding.encode(text))
+
+def chunk_text(text: str, target_size: int = 700, overlap: int = 100) -> list:
+    """Split text into chunks of target_size with overlap using tokens."""
+    tokens = encoding.encode(text)
+    total_tokens = len(tokens)
+    
+    if total_tokens <= 800:
+        return [text]
+        
+    chunks = []
+    start = 0
+    step = target_size - overlap
+    
+    while start < total_tokens:
+        end = min(start + target_size, total_tokens)
+        chunk_tokens = tokens[start:end]
+        chunk_text = encoding.decode(chunk_tokens)
+        chunks.append(chunk_text)
+        
+        # If we reached the end, break
+        if end == total_tokens:
+            break
+            
+        start += step
+        
+    return chunks
+
+def main():
+    input_file = PARSED_DIR / "valid_advisories.json"
+    if not input_file.exists():
+        print(f"Valid advisories file {input_file} not found!")
+        return
+        
+    with open(input_file, "r", encoding="utf-8") as f:
+        records = json.load(f)
+        
+    all_chunks = []
+    
+    for r in records:
+        content = r["content"]
+        chunks = chunk_text(content, target_size=700, overlap=100)
+        
+        for idx, chunk_content in enumerate(chunks, start=1):
+            chunk_record = {
+                "season": r["season"],
+                "source": r["source"],
+                "state": r["state"],
+                "category": r["category"],
+                "crop": r["crop"],
+                "page": r["page"],
+                "chunk_id": idx,
+                "content": chunk_content.strip(),
+                "token_count": count_tokens(chunk_content)
+            }
+            all_chunks.append(chunk_record)
+            
+    output_file = PARSED_DIR / "chunks.json"
+    with open(output_file, "w", encoding="utf-8") as f:
+        json.dump(all_chunks, f, indent=2, ensure_ascii=False)
+        
+    print(f"Chunking summary:")
+    print(f"  Total source advisories: {len(records)}")
+    print(f"  Generated chunks: {len(all_chunks)}")
+    print(f"  Saved to: {output_file}")
+
+if __name__ == "__main__":
+    main()

pipeline/05_embed_upload.py

@@ -0,0 +1,100 @@
+import os
+import json
+import hashlib
+from pathlib import Path
+from dotenv import load_dotenv
+from sentence_transformers import SentenceTransformer
+from pinecone import Pinecone, ServerlessSpec
+
+# Load Environment Variables
+BASE_DIR = Path(__file__).resolve().parent.parent
+load_dotenv(dotenv_path=BASE_DIR / ".env")
+
+PINECONE_API_KEY = os.getenv("PINECONE_API_KEY")
+PINECONE_INDEX_NAME = os.getenv("PINECONE_INDEX_NAME")
+
+PARSED_DIR = BASE_DIR / "data" / "parsed"
+
+def main():
+    if not PINECONE_API_KEY or PINECONE_API_KEY == "your_pinecone_api_key":
+        print("Error: PINECONE_API_KEY is not set in environment variables.")
+        return
+    if not PINECONE_INDEX_NAME or PINECONE_INDEX_NAME == "farmrisk-advisories":
+        print("Error: PINECONE_INDEX_NAME is not set in environment variables.")
+        return
+
+    # Load Chunks
+    chunks_file = PARSED_DIR / "chunks.json"
+    if not chunks_file.exists():
+        print(f"Chunks file {chunks_file} not found!")
+        return
+
+    with open(chunks_file, "r", encoding="utf-8") as f:
+        chunks = json.load(f)
+
+    if not chunks:
+        print("No chunks to upload.")
+        return
+
+    print(f"Loading SentenceTransformer model 'BAAI/bge-small-en-v1.5'...")
+    model = SentenceTransformer("BAAI/bge-small-en-v1.5")
+    
+    print("Connecting to Pinecone...")
+    pc = Pinecone(api_key=PINECONE_API_KEY)
+    
+    # Create index if it does not exist
+    existing_indexes = [index.name for index in pc.list_indexes()]
+    if PINECONE_INDEX_NAME not in existing_indexes:
+        print(f"Index '{PINECONE_INDEX_NAME}' not found. Creating a new index...")
+        pc.create_index(
+            name=PINECONE_INDEX_NAME,
+            dimension=384,
+            metric="cosine",
+            spec=ServerlessSpec(
+                cloud="aws",
+                region="us-east-1"
+            )
+        )
+        print(f"Index '{PINECONE_INDEX_NAME}' created successfully.")
+    else:
+        print(f"Index '{PINECONE_INDEX_NAME}' already exists.")
+
+    index = pc.Index(PINECONE_INDEX_NAME)
+
+    print(f"Embedding and uploading {len(chunks)} chunks in batches of 100...")
+    batch_size = 100
+    for i in range(0, len(chunks), batch_size):
+        batch = chunks[i:i + batch_size]
+        
+        # Prepare contents to embed
+        texts = [item["content"] for item in batch]
+        embeddings = model.encode(texts, normalize_embeddings=True)
+        
+        upsert_data = []
+        for idx, item in enumerate(batch):
+            # Create a unique ID
+            safe_state = item["state"].lower().replace(" ", "_").replace("&", "and")
+            safe_crop = item["crop"].lower().replace(" ", "_")
+            safe_season = item["season"].lower()
+            unique_id = f"{safe_state}_{safe_crop}_{safe_season}_{item['chunk_id']}"
+            
+            upsert_data.append((
+                unique_id,
+                embeddings[idx].tolist(),
+                {
+                    "crop": item["crop"],
+                    "state": item["state"],
+                    "season": item["season"],
+                    "source": item["source"],
+                    "page": item["page"],
+                    "category": item["category"]
+                }
+            ))
+            
+        index.upsert(vectors=upsert_data)
+        print(f"  Upserted batch {i//batch_size + 1}/{len(chunks)//batch_size + 1} (items {i} to {i + len(batch)})")
+
+    print("Pinecone upload complete!")
+
+if __name__ == "__main__":
+    main()

pipeline/run_all.py

@@ -0,0 +1,27 @@
+import subprocess
+import sys
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+def run_script(script_name: str):
+    script_path = BASE_DIR / "pipeline" / script_name
+    print(f"\n==========================================")
+    print(f"Running: {script_name}")
+    print(f"==========================================\n")
+    
+    result = subprocess.run([sys.executable, str(script_path)], cwd=BASE_DIR)
+    if result.returncode != 0:
+        print(f"\nError: {script_name} failed with return code {result.returncode}")
+        sys.exit(result.returncode)
+
+def main():
+    # Note: 01_extract.py is omitted as it has already been executed to dump raw text JSONs.
+    run_script("02_parse.py")
+    run_script("03_validate.py")
+    run_script("04_chunk.py")
+    run_script("05_embed_upload.py")
+    print("\nFull Ingestion Pipeline completed successfully!")
+
+if __name__ == "__main__":
+    main()

rag/extract.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+import fitz
+import json
+from tqdm import tqdm
+
+PDF_FOLDER = Path("data/pdfs")
+OUTPUT_FOLDER = Path("data/extracted")
+
+OUTPUT_FOLDER.mkdir(exist_ok=True)
+
+for pdf_file in PDF_FOLDER.glob("*.pdf"):
+
+    print(f"Reading {pdf_file.name}")
+
+    pdf = fitz.open(pdf_file)
+
+    pages = []
+
+    for page_number, page in enumerate(tqdm(pdf), start=1):
+
+        text = page.get_text("text")
+
+        pages.append({
+            "page": page_number,
+            "text": text
+        })
+
+    output_file = OUTPUT_FOLDER / f"{pdf_file.stem}.json"
+
+    with open(output_file, "w", encoding="utf-8") as f:
+
+        json.dump(
+            pages,
+            f,
+            ensure_ascii=False,
+            indent=2
+        )
+
+print("Done")

requirements.txt

@@ -0,0 +1,30 @@
+annotated-doc==0.0.4
+annotated-types==0.7.0
+anyio==4.14.1
+click==8.4.2
+colorama==0.4.6
+fastapi==0.138.1
+h11==0.16.0
+idna==3.18
+numpy==2.5.0
+pandas==3.0.3
+pydantic==2.13.4
+pydantic_core==2.46.4
+PyMuPDF==1.27.2.3
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.2
+six==1.17.0
+starlette==1.3.1
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2026.2
+uvicorn==0.49.0
+
+# Added for AI Knowledge Pipeline
+sentence-transformers==3.0.1
+pinecone-client==5.0.1
+tiktoken==0.7.0
+google-genai>=1.0.0
+httpx==0.27.0
+structlog==24.4.0
+groq>=0.9.0