Update app.py

app.py

@@ -1,4 +1,5 @@
-from fastapi import FastAPI, HTTPException, Header, Request
+# app.py
+from fastapi import FastAPI, HTTPException, Header, Request, Query
 from pydantic import BaseModel
 import requests
 import json
@@ -8,77 +9,60 @@ import pandas as pd
 import os
 import re
 import statistics
-from datetime import datetime
-from typing import Optional, Dict, Any, List
-
-app = FastAPI()
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any, List, Union
+import requests
+import urllib.parse
 
-# Your Retell.ai secret key (get from Retell.ai dashboard)
-RETELL_SECRET_KEY = "key_bdb05277a4587c7441bdad4a2c1b"
+app = FastAPI(title="Krishi Mitra API")
 
-# --- WEATHER CONFIG ---
-WEATHER_API_KEY = "ee75ffd59875aa5ca6c207e594336b30"
+# -------------------------
+# Configuration (update with env vars in production)
+# -------------------------
+RETELL_SECRET_KEY = os.getenv("RETELL_SECRET_KEY", "key_bdb05277a4587c7441bdad4a2c1b")
+WEATHER_API_KEY = os.getenv("WEATHER_API_KEY", "ee75ffd59875aa5ca6c207e594336b30")
 
-# Load CSV data on startup
+# -------------------------
+# CSV loader
+# -------------------------
 def load_csv_data():
-    """Load all CSV files into memory"""
+    """Load all CSV files into memory; trim whitespace from columns and string cells."""
     data = {}
     csv_files = {
-        'contact_info': '/app/data/contact_info.csv',
-        'crop_advisory': '/app/data/crop_advisory.csv',
-        'government_schemes': '/app/data/government_schemes.csv'
+        'contact_info': './data/contact_info.csv',
+        'crop_advisory': './data/crop_advisory.csv',
+        'government_schemes': './data/government_schemes.csv',
+        'market_prices': './data/market_prices.csv'
     }
 
     for key, file_path in csv_files.items():
         try:
             if os.path.exists(file_path):
-                data[key] = pd.read_csv(file_path)
-                # Strip whitespace from column names and string values
-                data[key].columns = data[key].columns.str.strip()
-                for col in data[key].select_dtypes(include=['object']).columns:
-                    data[key][col] = data[key][col].astype(str).str.strip()
-                print(f"Loaded {key}: {len(data[key])} records")
+                df = pd.read_csv(file_path)
+                # strip whitespace from column names
+                df.columns = df.columns.str.strip()
+                # strip whitespace from string columns
+                for col in df.select_dtypes(include=['object']).columns:
+                    df[col] = df[col].astype(str).str.strip()
+                data[key] = df
+                print(f"Loaded {key} ({file_path}): {len(df)} records")
             else:
-                print(f"Warning: {file_path} not found")
+                print(f"Warning: {file_path} not found - {key} will be empty")
                 data[key] = pd.DataFrame()
         except Exception as e:
-            print(f"Error loading {key}: {str(e)}")
+            print(f"Error loading {file_path}: {e}")
             data[key] = pd.DataFrame()
-
     return data
 
-# Load CSV data
 csv_data = load_csv_data()
 
-def get_weather(city: str):
-    """Fetches weather data from OpenWeatherMap API."""
-    if not city:
-        return None, None, None, None
-    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={WEATHER_API_KEY}&units=metric"
-    try:
-        response = requests.get(url, timeout=5)
-        response.raise_for_status()
-        data = response.json()
-
-        # OpenWeather returns cod as int or string depending on response
-        if str(data.get("cod")) == "200":
-            weather_description = data['weather'][0]['description']
-            temperature = data['main']['temp']
-            humidity = data['main']['humidity']
-            pressure = data['main']['pressure']
-            return temperature, humidity, weather_description, pressure
-    except Exception as e:
-        print(f"Error fetching weather data: {e}")
-
-    return None, None, None, None
-
-class RetellRequest(BaseModel):
-    name: str  # Function name
-    call: Dict[str, Any]  # Call object with transcript and context
-    args: Dict[str, Any]  # Function arguments
-
-def verify_retell_signature(request_body: bytes, signature: str) -> bool:
-    """Verify the request is from Retell.ai"""
+# -------------------------
+# Helpers
+# -------------------------
+def verify_retell_signature(request_body: bytes, signature: Optional[str]) -> bool:
+    """Verify the request is from Retell.ai if signature provided. If no signature, treat as allowed (for local testing)."""
+    if not signature:
+        return True
     expected_signature = hmac.new(
         RETELL_SECRET_KEY.encode(),
         request_body,
@@ -86,55 +70,32 @@ def verify_retell_signature(request_body: bytes, signature: str) -> bool:
     ).hexdigest()
     return hmac.compare_digest(signature, expected_signature)
 
-def search_csv_data(df: pd.DataFrame, search_terms: Dict[str, str]) -> pd.DataFrame:
-    """Search dataframe based on multiple criteria"""
-    if df.empty:
-        return df
-
-    result = df.copy()
-    for column, value in search_terms.items():
-        if column in df.columns and value:
-            # Case-insensitive partial matching
-            result = result[result[column].astype(str).str.contains(value, case=False, na=False)]
-
-    return result
-
-# -------------------------
-# Helper utilities
-# -------------------------
 def find_column(df: pd.DataFrame, candidates: List[str]) -> Optional[str]:
     """Return first matching column name from candidates (case-insensitive) or None."""
     cols = {c.lower(): c for c in df.columns}
     for cand in candidates:
-        if cand.lower() in cols:
+        if cand and cand.lower() in cols:
             return cols[cand.lower()]
     return None
 
 def extract_number_from_price(val: Any) -> Optional[float]:
-    """
-    Try to extract numeric value from price strings like "₹2,180 per quintal" or "2180".
-    Returns float or None if not parseable.
-    """
+    """Extract numeric value from messy price strings like '₹2,180 per quintal'."""
     if pd.isna(val):
         return None
     if isinstance(val, (int, float)):
         return float(val)
     s = str(val)
-    # remove currency symbols and non-digit characters except dot and minus
-    # first try to find first numeric group
-    # remove common words like per, quintal
-    # Use regex to capture numbers like 2,180.50 or 2180.5
-    match = re.search(r"(-?\d{1,3}(?:[,]\d{3})*(?:\.\d+)?|-?\d+(?:\.\d+)?)", s.replace('₹','').replace('Rs','').replace('INR',''))
+    s = s.replace('₹', '').replace('Rs', '').replace('INR', '')
+    match = re.search(r"(-?\d{1,3}(?:[,]\d{3})*(?:\.\d+)?|-?\d+(?:\.\d+)?)", s)
     if match:
-        num = match.group(0).replace(',', '')
         try:
-            return float(num)
+            return float(match.group(0).replace(',', ''))
         except:
             return None
     return None
 
 def format_scheme_row(row: pd.Series, mapping: Dict[str,str]) -> Dict[str,str]:
-    """Build a consistent scheme dict from a CSV row using mapping of fields to column names."""
+    """Normalize scheme row into dict keys used in responses."""
     return {
         "scheme": row.get(mapping.get("name", ""), "N/A"),
         "introduction": row.get(mapping.get("introduction", ""), ""),
@@ -143,21 +104,16 @@ def format_scheme_row(row: pd.Series, mapping: Dict[str,str]) -> Dict[str,str]:
         "eligibility": row.get(mapping.get("eligibility", ""), ""),
         "process": row.get(mapping.get("process", ""), "Contact local agriculture office"),
         "contact": row.get(mapping.get("contact", ""), ""),
-        "extra": row.get(mapping.get("extra", ""), ""),
+        "extra": row.get(mapping.get("extra", ""), "")
     }
 
 def get_schemes_from_csv(farmer_category: str, land_size: float, state: str, crop_type: str) -> List[Dict[str,str]]:
-    """
-    Read government_schemes dataframe and return a list of scheme dicts.
-    This function attempts to surface the most relevant schemes first but will
-    return all schemes if filtering doesn't match.
-    """
+    """Return list of scheme dicts from government_schemes CSV (with simple heuristics)."""
     schemes_out = []
     df = csv_data.get('government_schemes', pd.DataFrame())
     if df.empty:
         return []
 
-    # build mapping for column names (supports different CSV header variants)
     mapping = {
         "name": find_column(df, ["Name", "scheme_name", "Scheme", "Scheme Name"]),
         "introduction": find_column(df, ["Introduction", "introduction", "Description"]),
@@ -169,18 +125,16 @@ def get_schemes_from_csv(farmer_category: str, land_size: float, state: str, cro
         "extra": find_column(df, ["Extra Details", "extra_details", "Extra"])
     }
 
-    # Build list of all schemes with formatting
     all_schemes = []
     for _, r in df.iterrows():
         all_schemes.append(format_scheme_row(r, mapping))
 
-    # Try to filter schemes based on simple heuristics:
     prioritized = []
     others = []
 
-    state_lower = state.lower() if state else ""
-    farmer_cat_lower = farmer_category.lower() if farmer_category else ""
-    crop_lower = crop_type.lower() if crop_type else ""
+    state_lower = (state or "").lower()
+    farmer_cat_lower = (farmer_category or "").lower()
+    crop_lower = (crop_type or "").lower()
 
     for s in all_schemes:
         elig = str(s.get("eligibility", "")).lower()
@@ -194,137 +148,438 @@ def get_schemes_from_csv(farmer_category: str, land_size: float, state: str, cro
         ]).lower()
 
         score = 0
-        # If scheme mentions the state explicitly -> higher relevance
         if state_lower and state_lower in text_blob:
             score += 2
-        # If eligibility explicitly mentions landholding and user has land_size > 0
         if land_size and ("land" in elig or "landholding" in elig or "land" in text_blob):
             score += 2
-        # If eligibility says "all farmers" or similar, raise modestly
-        if "all" in elig or "all farmers" in elig or "all landholding" in elig:
+        if "all" in elig or "all farmers" in elig:
             score += 1
-        # crop-specific mention
         if crop_lower and crop_lower in text_blob:
             score += 2
-        # farmer category mention
         if farmer_cat_lower and farmer_cat_lower in text_blob:
             score += 1
 
-        # Put high-scored into prioritized list
         if score >= 2:
             prioritized.append((score, s))
         else:
             others.append((score, s))
 
-    # sort priority by score desc
     prioritized.sort(key=lambda x: x[0], reverse=True)
     others.sort(key=lambda x: x[0], reverse=True)
 
-    # return only scheme dicts, prioritized first
     schemes_out = [s for _, s in prioritized] + [s for _, s in others]
     return schemes_out
 
 # -------------------------
-# End helpers
+# Weather helper (simple)
 # -------------------------
+def get_weather(city: str):
+    """Fetch weather data from OpenWeatherMap API. Returns (temperature, humidity, description, pressure) or (None,...)."""
+    if not city:
+        return None, None, None, None
+    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={WEATHER_API_KEY}&units=metric"
+    try:
+        resp = requests.get(url, timeout=5)
+        resp.raise_for_status()
+        data = resp.json()
+        if str(data.get("cod")) == "200":
+            weather_description = data['weather'][0]['description']
+            temperature = data['main']['temp']
+            humidity = data['main']['humidity']
+            pressure = data['main']['pressure']
+            return temperature, humidity, weather_description, pressure
+    except Exception as e:
+        print(f"Weather fetch error: {e}")
+    return None, None, None, None
 
-@app.post("/api/market-prices")
-async def market_prices(request: dict):
-    # Keep your request shape usage intact
-    crop_name = request.get("query", {}).get("crop_name", "").strip()
-    state = request.get("query", {}).get("state", "").strip()
-    district = request.get("query", {}).get("district", "").strip()
-
-    # Safely handle missing CSV or missing expected columns
-    if "crop_advisory" in csv_data and not csv_data["crop_advisory"].empty:
-        df = csv_data["crop_advisory"].copy()
-
-        # find likely column names for crop, state, district, price
-        crop_col = find_column(df, ["crop_name", "crop", "Crop", "Crop Name"])
-        state_col = find_column(df, ["state", "State", "state_name"])
-        district_col = find_column(df, ["district", "District", "district_name"])
-        price_col = find_column(df, ["price", "Price", "market_price", "market price", "price_per_quintal"])
-
-        # build mask progressively (use contains if exact match column not present)
-        mask = pd.Series([True] * len(df))
-        if crop_col and crop_name:
-            mask = mask & df[crop_col].astype(str).str.contains(crop_name, case=False, na=False)
-        if state_col and state:
-            mask = mask & df[state_col].astype(str).str.contains(state, case=False, na=False)
-        if district_col and district:
-            mask = mask & df[district_col].astype(str).str.contains(district, case=False, na=False)
-
-        matches = df[mask]
-
-        if not matches.empty:
-            # compute average over numeric-parsable values in price_col if exists
-            avg_price = None
-            parsed_prices = []
-            if price_col:
-                for v in matches[price_col].tolist():
-                    num = extract_number_from_price(v)
-                    if num is not None:
-                        parsed_prices.append(num)
-                if parsed_prices:
-                    try:
-                        avg_price = statistics.mean(parsed_prices)
-                    except Exception:
-                        avg_price = None
-
-            if avg_price is not None:
-                result = f"The average market price of {crop_name} in {district}, {state} is ₹{avg_price:.2f} per quintal."
+# -------------------------
+# Market Prices Helper Functions (Updated for CSV)
+# -------------------------
+def get_market_prices_from_csv(state: str, district: Optional[str] = None, crop_name: Optional[str] = None):
+    """
+    Fetch market price data from local CSV file
+    Returns (success: bool, data: list, message: str)
+    """
+    try:
+        # Load market prices CSV
+        market_df = csv_data.get('market_prices', pd.DataFrame())
+        
+        # If market_prices not loaded, try to load it directly
+        if market_df.empty:
+            market_csv_path = './data/market_prices.csv'
+            if os.path.exists(market_csv_path):
+                market_df = pd.read_csv(market_csv_path)
+                # Clean column names and string data
+                market_df.columns = market_df.columns.str.strip()
+                for col in market_df.select_dtypes(include=['object']).columns:
+                    market_df[col] = market_df[col].astype(str).str.strip()
+                # Update the global csv_data
+                csv_data['market_prices'] = market_df
             else:
-                # If price_col absent or non-numeric, fallback to your previous text but mention CSV found
-                result = f"Market data found for {crop_name} in {district}, {state} but numeric price values were not available."
+                return False, [], f"Market prices CSV file not found at {market_csv_path}"
+        
+        if market_df.empty:
+            return False, [], "No market price data available"
+        
+        # Find relevant columns (case-insensitive matching)
+        state_col = find_column(market_df, ["State", "state"])
+        district_col = find_column(market_df, ["District", "district"])  
+        commodity_col = find_column(market_df, ["Commodity", "commodity", "Crop", "crop"])
+        market_col = find_column(market_df, ["Market", "market"])
+        variety_col = find_column(market_df, ["Variety", "variety"])
+        date_col = find_column(market_df, ["Arrival_Date", "arrival_date", "Date", "date"])
+        min_price_col = find_column(market_df, ["Min_x0020_Price", "min_price", "Min_Price", "Minimum_Price"])
+        max_price_col = find_column(market_df, ["Max_x0020_Price", "max_price", "Max_Price", "Maximum_Price"])  
+        modal_price_col = find_column(market_df, ["Modal_x0020_Price", "modal_price", "Modal_Price", "Average_Price"])
+        
+        if not state_col:
+            return False, [], "State column not found in market prices data"
+            
+        # Filter by state (case-insensitive)
+        filtered_df = market_df[market_df[state_col].astype(str).str.contains(state, case=False, na=False)]
+        
+        # Filter by district if provided
+        if district and district_col:
+            filtered_df = filtered_df[filtered_df[district_col].astype(str).str.contains(district, case=False, na=False)]
+            
+        # Filter by crop/commodity if provided  
+        if crop_name and commodity_col:
+            filtered_df = filtered_df[filtered_df[commodity_col].astype(str).str.contains(crop_name, case=False, na=False)]
+            
+        if filtered_df.empty:
+            return False, [], f"No market price data found for the specified criteria"
+            
+        # Convert to list of dictionaries
+        processed_data = []
+        for _, record in filtered_df.iterrows():
+            processed_record = {
+                "state": record.get(state_col, "") if state_col else "",
+                "district": record.get(district_col, "") if district_col else "",
+                "market": record.get(market_col, "") if market_col else "",
+                "commodity": record.get(commodity_col, "") if commodity_col else "",
+                "variety": record.get(variety_col, "") if variety_col else "",
+                "arrival_date": record.get(date_col, "") if date_col else "",
+                "min_price": record.get(min_price_col, "") if min_price_col else "",
+                "max_price": record.get(max_price_col, "") if max_price_col else "",
+                "modal_price": record.get(modal_price_col, "") if modal_price_col else ""
+            }
+            processed_data.append(processed_record)
+            
+        return True, processed_data, f"Found {len(processed_data)} market price records"
+        
+    except Exception as e:
+        return False, [], f"Error processing market data: {str(e)}"
 
+def format_market_prices_response(data: List[Dict], state: str, district: Optional[str] = None, crop_name: Optional[str] = None):
+    """
+    Format market price data into a voice-friendly response
+    """
+    if not data:
+        location_text = f"{district}, {state}" if district else state
+        return f"No current market price data available for {location_text}. Please contact your local market or agriculture office for current rates."
+    
+    # Group data by commodity for better presentation
+    commodity_data = {}
+    for record in data:
+        commodity = record.get("commodity", "Unknown")
+        if commodity not in commodity_data:
+            commodity_data[commodity] = []
+        commodity_data[commodity].append(record)
+    
+    # Build response text
+    location_text = f"{district}, {state}" if district else state
+    
+    if crop_name and crop_name.lower() in [c.lower() for c in commodity_data.keys()]:
+        # Specific crop requested
+        matching_commodity = next(c for c in commodity_data.keys() if c.lower() == crop_name.lower())
+        crop_records = commodity_data[matching_commodity]
+        
+        if len(crop_records) == 1:
+            record = crop_records[0]
+            response_text = f"Market price for {matching_commodity} in {record.get('market', location_text)}: "
+            
+            # Clean and format prices
+            min_price = extract_number_from_price(record.get('min_price', ''))
+            max_price = extract_number_from_price(record.get('max_price', ''))
+            modal_price = extract_number_from_price(record.get('modal_price', ''))
+            
+            if min_price is not None:
+                response_text += f"Minimum ₹{min_price:.0f}, "
+            if max_price is not None:
+                response_text += f"Maximum ₹{max_price:.0f}, "
+            if modal_price is not None:
+                response_text += f"Modal price ₹{modal_price:.0f} per quintal. "
+            else:
+                response_text += "per quintal. "
+                
+            if record.get('arrival_date'):
+                response_text += f"Data from {record.get('arrival_date')}."
+        else:
+            # Multiple records for the same commodity
+            min_prices = []
+            max_prices = []
+            modal_prices = []
+            
+            for r in crop_records:
+                min_p = extract_number_from_price(r.get('min_price', ''))
+                max_p = extract_number_from_price(r.get('max_price', ''))
+                modal_p = extract_number_from_price(r.get('modal_price', ''))
+                
+                if min_p is not None:
+                    min_prices.append(min_p)
+                if max_p is not None:
+                    max_prices.append(max_p)
+                if modal_p is not None:
+                    modal_prices.append(modal_p)
+            
+            response_text = f"Market prices for {matching_commodity} in {location_text}: "
+            if min_prices and max_prices:
+                response_text += f"Price range ₹{min(min_prices):.0f} to ₹{max(max_prices):.0f} per quintal. "
+            if modal_prices:
+                avg_modal = sum(modal_prices) / len(modal_prices)
+                response_text += f"Average modal price ₹{avg_modal:.0f} per quintal. "
+            response_text += f"Data from {len(crop_records)} markets."
+    else:
+        # General market overview or multiple commodities
+        response_text = f"Current market prices in {location_text}: "
+        
+        commodity_summaries = []
+        for commodity, records in list(commodity_data.items())[:5]:  # Limit to 5 commodities for voice
+            if records:
+                modal_prices = []
+                for r in records:
+                    modal_p = extract_number_from_price(r.get('modal_price', ''))
+                    if modal_p is not None:
+                        modal_prices.append(modal_p)
+                        
+                if modal_prices:
+                    avg_price = sum(modal_prices) / len(modal_prices)
+                    commodity_summaries.append(f"{commodity} at ₹{avg_price:.0f}")
+                else:
+                    commodity_summaries.append(f"{commodity} (price varies)")
+        
+        if commodity_summaries:
+            response_text += ", ".join(commodity_summaries) + " per quintal. "
+        
+        if len(commodity_data) > 5:
+            response_text += f"And {len(commodity_data) - 5} more commodities available."
+    
+    return response_text
+
+# -------------------------
+# Request models (if needed)
+# -------------------------
+class RetellRequest(BaseModel):
+    name: str
+    call: Dict[str, Any]
+    args: Dict[str, Any]
+
+# -------------------------
+# Endpoints
+# -------------------------
+
+# Root and health
+@app.get("/")
+async def root():
+    return {
+        "message": "Krishi Mitra API is running!",
+        "endpoints": [
+            "/api/market-prices (GET|POST)",
+            "/api/scheme-eligibility (GET|POST)",
+            "/api/weather-advisory (GET|POST)",
+            "/api/crop-advisory (GET|POST)",
+            "/api/csv-status (GET)",
+            "/health (GET)"
+        ]
+    }
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy",
+        "service": "Krishi Mitra API",
+        "csv_files_loaded": {key: len(df) for key, df in csv_data.items()}
+    }
+
+@app.get("/api/csv-status")
+async def csv_status():
+    """Check status of loaded CSV files"""
+    status = {}
+    for key, df in csv_data.items():
+        status[key] = {
+            "loaded": not df.empty,
+            "records": len(df),
+            "columns": list(df.columns) if not df.empty else []
+        }
+    return status
+
+# -------------------------
+# Market prices (Updated for CSV)
+# -------------------------
+@app.post("/api/market-prices")
+async def market_prices_post(request: Request):
+    """
+    Get market prices from local CSV data
+    """
+    try:
+        body = await request.json() if (await request.body()) else {}
+        
+        # Extract parameters from different possible locations in payload
+        query_params = body.get("query", {})
+        args_params = body.get("args", {})
+        
+        crop_name = (
+            query_params.get("crop_name", "") or 
+            args_params.get("crop_name", "") or 
+            body.get("crop_name", "")
+        ).strip()
+        
+        state = (
+            query_params.get("state", "") or 
+            args_params.get("state", "") or 
+            body.get("state", "")
+        ).strip()
+        
+        district = (
+            query_params.get("district", "") or 
+            args_params.get("district", "") or 
+            body.get("district", "")
+        ).strip()
+        
+        if not state:
+            return {
+                "success": False,
+                "result": "Please provide state name to get market prices.",
+                "data": []
+            }
+        
+        # Fetch market data from CSV
+        success, data, message = get_market_prices_from_csv(state, district or None, crop_name or None)
+        
+        if success:
+            response_text = format_market_prices_response(data, state, district or None, crop_name or None)
             return {
                 "success": True,
-                "result": result,
-                "data": matches.to_dict(orient="records")
+                "result": response_text,
+                "data": data[:10],  # Limit response data for voice interface
+                "total_records": len(data)
             }
+        else:
+            # Fallback message
+            location_text = f"{district}, {state}" if district else state
+            fallback_message = f"Current market price data for {location_text} is not available right now. Please contact your local mandi or agriculture market committee for current rates."
+            
+            return {
+                "success": False,
+                "result": fallback_message,
+                "data": [],
+                "error": message
+            }
+            
+    except Exception as e:
+        return {
+            "success": False,
+            "result": "I'm having trouble accessing market price data right now. Please contact your local mandi for current rates.",
+            "data": [],
+            "error": str(e)
+        }
 
-    # fallback to previous mock behavior (keeps your logic)
-    return {
-        "success": False,
-        "result": f"No market price data found for {crop_name} in {district}, {state}."
-    }
+@app.get("/api/market-prices")
+async def market_prices_get(
+    crop_name: Optional[str] = Query("", alias="crop_name"),
+    state: Optional[str] = Query("", alias="state"), 
+    district: Optional[str] = Query("", alias="district")
+):
+    """
+    Get market prices via GET request from local CSV
+    """
+    if not state:
+        return {
+            "success": False,
+            "result": "Please provide state parameter to get market prices.",
+            "data": []
+        }
+    
+    try:
+        # Fetch market data from CSV
+        success, data, message = get_market_prices_from_csv(state.strip(), district.strip() if district else None, crop_name.strip() if crop_name else None)
+        
+        if success:
+            response_text = format_market_prices_response(data, state.strip(), district.strip() if district else None, crop_name.strip() if crop_name else None)
+            return {
+                "success": True,
+                "result": response_text,
+                "data": data[:10],  # Limit response data
+                "total_records": len(data)
+            }
+        else:
+            # Fallback message
+            location_text = f"{district}, {state}" if district else state
+            fallback_message = f"Current market price data for {location_text} is not available right now. Please contact your local mandi or agriculture market committee for current rates."
+            
+            return {
+                "success": False,
+                "result": fallback_message,
+                "data": [],
+                "error": message
+            }
+            
+    except Exception as e:
+        return {
+            "success": False,
+            "result": "I'm having trouble accessing market price data right now. Please contact your local mandi for current rates.",
+            "data": [],
+            "error": str(e)
+        }
 
+# -------------------------
+# Scheme eligibility (POST for Retell style, GET for easy testing)
+# -------------------------
 @app.post("/api/scheme-eligibility")
 async def scheme_eligibility_endpoint(
     request: Request,
-    x_retell_signature: str = Header(None, alias="X-Retell-Signature")
+    x_retell_signature: Optional[str] = Header(None, alias="X-Retell-Signature")
 ):
-    """Handle scheme eligibility function call from Retell.ai"""
     request_body = await request.body()
-    retell_request = json.loads(request_body.decode('utf-8'))
+    # verify signature if header present
+    if x_retell_signature and not verify_retell_signature(request_body, x_retell_signature):
+        raise HTTPException(status_code=401, detail="Invalid Retell signature")
+
+    try:
+        payload = json.loads(request_body.decode('utf-8')) if request_body else {}
+    except Exception:
+        payload = {}
 
-    # Extract arguments
-    farmer_category = retell_request["args"].get("farmer_category", "")
-    land_size = retell_request["args"].get("land_size", 0)
-    state = retell_request["args"].get("state", "")
-    crop_type = retell_request["args"].get("crop_type", "")
+    farmer_category = payload.get("args", {}).get("farmer_category", "") or payload.get("farmer_category", "")
+    land_size = payload.get("args", {}).get("land_size", 0) or payload.get("land_size", 0)
+    state = payload.get("args", {}).get("state", "") or payload.get("state", "")
+    crop_type = payload.get("args", {}).get("crop_type", "") or payload.get("crop_type", "")
 
     try:
         eligible_schemes = []
-
-        # Search government schemes CSV and apply simple relevance heuristics
         if not csv_data['government_schemes'].empty:
-            eligible_schemes = get_schemes_from_csv(farmer_category, land_size, state, crop_type)
-
-        # Add default schemes if no CSV data or as fallback
+            # ensure land_size numeric
+            try:
+                land_size_f = float(land_size) if land_size not in [None, ""] else 0.0
+            except:
+                land_size_f = 0.0
+            eligible_schemes = get_schemes_from_csv(farmer_category or "", land_size_f, state or "", crop_type or "")
+
+        # Fallback defaults
         if not eligible_schemes:
-            # PM-KISAN eligibility
-            if land_size and float(land_size) > 0:
+            try:
+                ls_f = float(land_size) if land_size not in [None, ""] else 0.0
+            except:
+                ls_f = 0.0
+            if ls_f > 0:
                 eligible_schemes.append({
                     "scheme": "PM-KISAN",
                     "benefit": "₹6,000 per year in 3 installments",
                     "description": "Direct income support to landholding farmer families.",
                     "eligibility": "All landholding farmer families.",
-                    "process": "Apply online at pmkisan.gov.in or visit nearest CSC",
+                    "process": "Apply via pmkisan.gov.in or your nearest CSC",
                     "contact": "https://pmkisan.gov.in/"
                 })
-
-            # Crop Insurance
             eligible_schemes.append({
                 "scheme": "Pradhan Mantri Fasal Bima Yojana",
                 "benefit": "Comprehensive crop insurance coverage",
@@ -333,9 +588,7 @@ async def scheme_eligibility_endpoint(
                 "process": "Contact your nearest bank, CSC or PMFBY portal",
                 "contact": "https://pmfby.gov.in/"
             })
-
-            # State-specific schemes
-            if state and state.lower() == "punjab":
+            if state and state.strip().lower() == "punjab":
                 eligible_schemes.append({
                     "scheme": "Punjab Crop Diversification Scheme",
                     "benefit": "₹17,500 per hectare for diversification",
@@ -343,15 +596,14 @@ async def scheme_eligibility_endpoint(
                     "contact": ""
                 })
 
-        # Format response for voice (limit to first 3 items, keep original style)
+        # Build voice-friendly text (limit first 3)
         if eligible_schemes:
             schemes_text = f"You are eligible for {len(eligible_schemes)} government schemes: "
-            for i, scheme in enumerate(eligible_schemes[:3]):  # Limit to first 3 for voice response
-                contact_info = f" Apply through {scheme.get('process','Contact local agriculture office')}" if scheme.get('process') else ""
+            for i, scheme in enumerate(eligible_schemes[:3]):
+                contact_info = f" Apply through {scheme.get('process','Contact local agriculture office')}"
                 if scheme.get('contact'):
                     contact_info += f" or contact {scheme.get('contact')}"
                 schemes_text += f"{i+1}. {scheme.get('scheme','N/A')} - {scheme.get('benefit', scheme.get('description','N/A'))}.{contact_info}. "
-
             if len(eligible_schemes) > 3:
                 schemes_text += f"And {len(eligible_schemes)-3} more schemes available."
         else:
@@ -364,22 +616,82 @@ async def scheme_eligibility_endpoint(
 
     except Exception as e:
         return {
-            "result": "I'm having trouble accessing scheme information right now. Please contact your local agriculture officer or visit the nearest CSC for scheme details.",
+            "result": "I'm having trouble accessing scheme information right now. Please contact your local agriculture officer.",
             "error": str(e)
         }
 
-@app.post("/api/weather-advisory")
-async def weather_advisory(request: dict):
-    # Keep your request shape usage intact
-    city = request.get("query", {}).get("location", "").strip()
+@app.get("/api/scheme-eligibility")
+async def scheme_eligibility_get(
+    farmer_category: Optional[str] = Query("", alias="farmer_category"),
+    land_size: Optional[float] = Query(0.0, alias="land_size"),
+    state: Optional[str] = Query("", alias="state"),
+    crop_type: Optional[str] = Query("", alias="crop_type")
+):
+    try:
+        eligible_schemes = []
+        if not csv_data['government_schemes'].empty:
+            eligible_schemes = get_schemes_from_csv(farmer_category or "", float(land_size or 0.0), state or "", crop_type or "")
 
+        if not eligible_schemes:
+            if float(land_size or 0.0) > 0:
+                eligible_schemes.append({
+                    "scheme": "PM-KISAN",
+                    "benefit": "₹6,000 per year in 3 installments",
+                    "description": "Direct income support to landholding farmer families.",
+                    "eligibility": "All landholding farmer families.",
+                    "process": "Apply via pmkisan.gov.in or your nearest CSC",
+                    "contact": "https://pmkisan.gov.in/"
+                })
+            eligible_schemes.append({
+                "scheme": "Pradhan Mantri Fasal Bima Yojana",
+                "benefit": "Comprehensive crop insurance coverage",
+                "description": "Crop insurance against natural calamities, pests, and diseases.",
+                "eligibility": "All farmers in notified crops/areas",
+                "process": "Contact your nearest bank, CSC or PMFBY portal",
+                "contact": "https://pmfby.gov.in/"
+            })
+            if state and state.strip().lower() == "punjab":
+                eligible_schemes.append({
+                    "scheme": "Punjab Crop Diversification Scheme",
+                    "benefit": "₹17,500 per hectare for diversification",
+                    "process": "Contact District Agriculture Officer",
+                    "contact": ""
+                })
+
+        # Build text
+        if eligible_schemes:
+            schemes_text = f"You are eligible for {len(eligible_schemes)} government schemes: "
+            for i, scheme in enumerate(eligible_schemes[:3]):
+                contact_info = f" Apply through {scheme.get('process','Contact local agriculture office')}"
+                if scheme.get('contact'):
+                    contact_info += f" or contact {scheme.get('contact')}"
+                schemes_text += f"{i+1}. {scheme.get('scheme','N/A')} - {scheme.get('benefit', scheme.get('description','N/A'))}.{contact_info}. "
+            if len(eligible_schemes) > 3:
+                schemes_text += f"And {len(eligible_schemes)-3} more schemes available."
+        else:
+            schemes_text = "I couldn't find specific schemes for your profile. Please contact your local agriculture department for personalized advice."
+
+        return {
+            "result": schemes_text,
+            "eligible_schemes": eligible_schemes
+        }
+
+    except Exception as e:
+        return {"result": "Error computing schemes", "error": str(e)}
+
+# -------------------------
+# Weather advisory (POST and GET)
+# -------------------------
+@app.post("/api/weather-advisory")
+async def weather_advisory_post(request: Request):
+    body = await request.json() if (await request.body()) else {}
+    city = body.get("query", {}).get("location", "").strip() if body else ""
     temperature, humidity, description, pressure = get_weather(city)
     if temperature is None:
-        # Fallback values
         temperature, humidity, description, pressure = 32.0, 60, "Not Available", 1012
         weather_condition = "NORMAL"
     else:
-        desc_lower = description.lower()
+        desc_lower = (description or "").lower()
         if "clear" in desc_lower:
             weather_condition = "SUNNY"
         elif "rain" in desc_lower:
@@ -390,7 +702,7 @@ async def weather_advisory(request: dict):
             weather_condition = "NORMAL"
 
     result = (
-        f"Weather in {city}: {description}. "
+        f"Weather in {city or 'your location'}: {description}. "
         f"Temperature {temperature}°C, Humidity {humidity}%, Pressure {pressure} hPa. "
         f"Condition classified as {weather_condition}."
     )
@@ -408,89 +720,132 @@ async def weather_advisory(request: dict):
         }
     }
 
+@app.get("/api/weather-advisory")
+async def weather_advisory_get(location: Optional[str] = Query("", alias="location")):
+    # delegate to same logic above
+    temperature, humidity, description, pressure = get_weather(location)
+    if temperature is None:
+        temperature, humidity, description, pressure = 32.0, 60, "Not Available", 1012
+        weather_condition = "NORMAL"
+    else:
+        desc_lower = (description or "").lower()
+        if "clear" in desc_lower:
+            weather_condition = "SUNNY"
+        elif "rain" in desc_lower:
+            weather_condition = "RAINY"
+        elif "wind" in desc_lower:
+            weather_condition = "WINDY"
+        else:
+            weather_condition = "NORMAL"
+
+    result = (
+        f"Weather in {location or 'your location'}: {description}. "
+        f"Temperature {temperature}°C, Humidity {humidity}%, Pressure {pressure} hPa. "
+        f"Condition classified as {weather_condition}."
+    )
+
+    return {
+        "success": True,
+        "result": result,
+        "data": {
+            "city": location,
+            "temperature": temperature,
+            "humidity": humidity,
+            "pressure": pressure,
+            "description": description,
+            "condition": weather_condition
+        }
+    }
+
+# -------------------------
+# Crop advisory (POST - Retell style; GET - query params)
+# -------------------------
 @app.post("/api/crop-advisory")
 async def crop_advisory_endpoint(
     request: Request,
-    x_retell_signature: str = Header(None, alias="X-Retell-Signature")
+    x_retell_signature: Optional[str] = Header(None, alias="X-Retell-Signature")
 ):
-    """Handle crop advisory function call from Retell.ai"""
     request_body = await request.body()
-    retell_request = json.loads(request_body.decode('utf-8'))
+    if x_retell_signature and not verify_retell_signature(request_body, x_retell_signature):
+        raise HTTPException(status_code=401, detail="Invalid Retell signature")
+
+    try:
+        payload = json.loads(request_body.decode('utf-8')) if request_body else {}
+    except Exception:
+        payload = {}
 
-    crop_name = retell_request["args"].get("crop_name", "")
-    growth_stage = retell_request["args"].get("growth_stage", "")
-    issue_type = retell_request["args"].get("issue_type", "general")
-    state = retell_request["args"].get("state", "")
+    crop_name = (payload.get("args", {}).get("crop_name", "") or payload.get("crop_name", "") or "").strip()
+    growth_stage = (payload.get("args", {}).get("growth_stage", "") or payload.get("growth_stage", "") or "").strip()
+    issue_type = (payload.get("args", {}).get("issue_type", "general") or payload.get("issue_type", "general") or "general").strip().lower()
+    state = (payload.get("args", {}).get("state", "") or payload.get("state", "") or "").strip()
 
     try:
         advisory = None
         contact_info = ""
 
-        # Search crop advisory CSV
-        if not csv_data['crop_advisory'].empty:
-            search_terms = {}
-            if crop_name:
-                # Search by crop name
-                crop_matches = csv_data['crop_advisory'][
-                    csv_data['crop_advisory']['crop'].str.contains(crop_name, case=False, na=False)
-                ]
-
-                if not crop_matches.empty:
-                    crop_info = crop_matches.iloc[0]
-
-                    # Build advisory based on available data
-                    advisory_parts = []
-
-                    if issue_type == "general":
-                        if pd.notna(crop_info.get('sowing_time')):
-                            advisory_parts.append(f"Sowing time: {crop_info['sowing_time']}")
-                        if pd.notna(crop_info.get('fertilizer')):
-                            advisory_parts.append(f"Recommended fertilizer: {crop_info['fertilizer']}")
-                        if pd.notna(crop_info.get('season')):
-                            advisory_parts.append(f"Best season: {crop_info['season']}")
-
-                    # Check for specific issues
-                    if pd.notna(crop_info.get('common_issues')) and pd.notna(crop_info.get('solution')):
-                        if issue_type in ['pest', 'disease'] or issue_type == 'general':
-                            advisory_parts.append(f"For {crop_info['common_issues']}: {crop_info['solution']}")
-
-                    if advisory_parts:
-                        advisory = f"For {crop_name}: " + ". ".join(advisory_parts)
-
-        # Search contact info CSV  
-        if not csv_data['contact_info'].empty and state:
-            # Search by state
-            contact_matches = csv_data['contact_info'][
-                csv_data['contact_info']['state'].str.contains(state, case=False, na=False)
-            ]
-
-            if not contact_matches.empty:
-                contact_match = contact_matches.iloc[0]
-                contact_parts = []
-
-                if pd.notna(contact_match.get('agriculture_officer')):
-                    contact_parts.append(f"Agriculture Officer at {contact_match['agriculture_officer']}")
-
-                if pd.notna(contact_match.get('kvk_contact')):
-                    contact_parts.append(f"KVK at {contact_match['kvk_contact']}")
-
-                if pd.notna(contact_match.get('kisan_call_center')):
-                    contact_parts.append(f"Kisan Call Center at {contact_match['kisan_call_center']}")
-
-                if contact_parts:
-                    contact_info = f"For detailed advice in {state}, contact: " + " or ".join(contact_parts) + "."
-
-        # Fallback advisory
+        # Search crop_advisory CSV robustly (support various column names)
+        df = csv_data.get('crop_advisory', pd.DataFrame())
+        if not df.empty:
+            # find likely columns
+            crop_col = find_column(df, ["crop", "Crop", "Crop Name", "crop_name"])
+            sowing_col = find_column(df, ["sowing_time", "Sowing_Time", "Sowing Time", "Sowing"])
+            fertilizer_col = find_column(df, ["fertilizer", "Fertilizer"])
+            season_col = find_column(df, ["season", "Season"])
+            issues_col = find_column(df, ["common_issues", "Common_Issues", "Common Issues", "Common_Issues"])
+            solution_col = find_column(df, ["solution", "Solution", "Solution"])
+
+            if crop_col and crop_name:
+                matches = df[df[crop_col].astype(str).str.contains(crop_name, case=False, na=False)]
+            elif crop_col:
+                matches = df.copy()
+            else:
+                matches = pd.DataFrame()
+
+            if not matches.empty:
+                crop_info = matches.iloc[0]
+                parts = []
+                if issue_type == "general":
+                    if sowing_col and pd.notna(crop_info.get(sowing_col)):
+                        parts.append(f"Sowing time: {crop_info[sowing_col]}")
+                    if fertilizer_col and pd.notna(crop_info.get(fertilizer_col)):
+                        parts.append(f"Recommended fertilizer: {crop_info[fertilizer_col]}")
+                    if season_col and pd.notna(crop_info.get(season_col)):
+                        parts.append(f"Best season: {crop_info[season_col]}")
+                if issues_col and solution_col and pd.notna(crop_info.get(issues_col)) and pd.notna(crop_info.get(solution_col)):
+                    if issue_type in ['pest', 'disease'] or issue_type == 'general':
+                        parts.append(f"For {crop_info[issues_col]}: {crop_info[solution_col]}")
+                if parts:
+                    advisory = f"For {crop_name or crop_info.get(crop_col,'the crop')}: " + ". ".join(parts)
+
+        # contact info from contact_info CSV
+        df_contact = csv_data.get('contact_info', pd.DataFrame())
+        if not df_contact.empty and state:
+            state_col = find_column(df_contact, ["state", "State", "state_name"])
+            if state_col:
+                contact_matches = df_contact[df_contact[state_col].astype(str).str.contains(state, case=False, na=False)]
+                if not contact_matches.empty:
+                    contact_match = contact_matches.iloc[0]
+                    contact_parts = []
+                    if 'agriculture_officer' in contact_match and pd.notna(contact_match.get('agriculture_officer')):
+                        contact_parts.append(f"Agriculture Officer at {contact_match['agriculture_officer']}")
+                    if 'kvk_contact' in contact_match and pd.notna(contact_match.get('kvk_contact')):
+                        contact_parts.append(f"KVK at {contact_match['kvk_contact']}")
+                    if 'kisan_call_center' in contact_match and pd.notna(contact_match.get('kisan_call_center')):
+                        contact_parts.append(f"Kisan Call Center at {contact_match['kisan_call_center']}")
+                    if contact_parts:
+                        contact_info = f"For detailed advice in {state}, contact: " + " or ".join(contact_parts) + "."
+
+        # fallback advisory if none found
         if not advisory:
-            if crop_name.lower() == "wheat" and issue_type == "pest":
-                advisory = "For wheat pest control: If you see aphids, spray Imidacloprid 200 SL at 0.3ml per liter of water. Spray during evening hours. Avoid over-irrigation which attracts pests."
-            elif crop_name.lower() == "rice" and issue_type == "disease":
+            if crop_name and crop_name.lower() == "wheat" and issue_type == "pest":
+                advisory = "For wheat pest control: If you see aphids, spray Imidacloprid 200 SL at 0.3ml per liter of water. Spray during evening hours. Avoid over-irrigation."
+            elif crop_name and crop_name.lower() == "rice" and issue_type == "disease":
                 advisory = "For rice disease management: If you see brown spots on leaves, it might be blast disease. Apply Tricyclazole 75% WP at 0.6g per liter. Ensure proper drainage."
             else:
-                advisory = f"For {crop_name} at {growth_stage} stage: Monitor crop regularly, maintain proper spacing, apply fertilizers as per soil test recommendations."
+                advisory = f"For {crop_name or 'the crop'} at {growth_stage or 'current'} stage: Monitor crop regularly, maintain proper spacing, apply fertilizers as per soil test recommendations."
 
         if not contact_info:
-            contact_info = f"For detailed advice, contact your local Krishi Vigyan Kendra or Agriculture Officer in {state}. You can also call the Kisan Call Centre at 1800-1801-551."
+            contact_info = f"For detailed advice, contact your local Krishi Vigyan Kendra or Agriculture Officer in {state or 'your state'}. You can also call the Kisan Call Centre at 1800-1801-551."
 
         result_text = f"{advisory} {contact_info}"
 
@@ -506,41 +861,99 @@ async def crop_advisory_endpoint(
             "error": str(e)
         }
 
-@app.get("/api/csv-status")
-async def csv_status():
-    """Check status of loaded CSV files"""
-    status = {}
-    for key, df in csv_data.items():
-        status[key] = {
-            "loaded": not df.empty,
-            "records": len(df),
-            "columns": list(df.columns) if not df.empty else []
-        }
-    return status
+@app.get("/api/crop-advisory")
+async def crop_advisory_get(
+    crop_name: Optional[str] = Query("", alias="crop_name"),
+    growth_stage: Optional[str] = Query("", alias="growth_stage"),
+    issue_type: Optional[str] = Query("general", alias="issue_type"),
+    state: Optional[str] = Query("", alias="state")
+):
+    try:
+        crop_name = (crop_name or "").strip()
+        growth_stage = (growth_stage or "").strip()
+        issue_type = (issue_type or "general").strip().lower()
+        state = (state or "").strip()
 
-# Health check endpoint
-@app.get("/health")
-async def health_check():
-    return {
-        "status": "healthy",
-        "service": "Krishi Mitra API",
-        "csv_files_loaded": {key: len(df) for key, df in csv_data.items()}
-    }
+        advisory = None
+        contact_info = ""
 
-@app.get("/")
-async def root():
-    return {
-        "message": "Krishi Mitra API is running!",
-        "endpoints": [
-            "/api/market-prices",
-            "/api/scheme-eligibility",
-            "/api/weather-advisory",
-            "/api/crop-advisory",
-            "/api/csv-status",
-            "/health"
-        ]
-    }
+        df = csv_data.get('crop_advisory', pd.DataFrame())
+        if not df.empty:
+            crop_col = find_column(df, ["crop", "Crop", "Crop Name", "crop_name"])
+            sowing_col = find_column(df, ["sowing_time", "Sowing_Time", "Sowing Time", "Sowing"])
+            fertilizer_col = find_column(df, ["fertilizer", "Fertilizer"])
+            season_col = find_column(df, ["season", "Season"])
+            issues_col = find_column(df, ["common_issues", "Common_Issues", "Common Issues"])
+            solution_col = find_column(df, ["solution", "Solution", "Solution"])
+
+            if crop_col and crop_name:
+                matches = df[df[crop_col].astype(str).str.contains(crop_name, case=False, na=False)]
+            elif crop_col:
+                matches = df.copy()
+            else:
+                matches = pd.DataFrame()
+
+            if not matches.empty:
+                crop_info = matches.iloc[0]
+                parts = []
+                if issue_type == "general":
+                    if sowing_col and pd.notna(crop_info.get(sowing_col)):
+                        parts.append(f"Sowing time: {crop_info[sowing_col]}")
+                    if fertilizer_col and pd.notna(crop_info.get(fertilizer_col)):
+                        parts.append(f"Recommended fertilizer: {crop_info[fertilizer_col]}")
+                    if season_col and pd.notna(crop_info.get(season_col)):
+                        parts.append(f"Best season: {crop_info[season_col]}")
+                if issues_col and solution_col and pd.notna(crop_info.get(issues_col)) and pd.notna(crop_info.get(solution_col)):
+                    if issue_type in ['pest', 'disease'] or issue_type == 'general':
+                        parts.append(f"For {crop_info[issues_col]}: {crop_info[solution_col]}")
+                if parts:
+                    advisory = f"For {crop_name or crop_info.get(crop_col,'the crop')}: " + ". ".join(parts)
+
+        # contact info
+        df_contact = csv_data.get('contact_info', pd.DataFrame())
+        if not df_contact.empty and state:
+            state_col = find_column(df_contact, ["state", "State", "state_name"])
+            if state_col:
+                contact_matches = df_contact[df_contact[state_col].astype(str).str.contains(state, case=False, na=False)]
+                if not contact_matches.empty:
+                    contact_match = contact_matches.iloc[0]
+                    contact_parts = []
+                    if 'agriculture_officer' in contact_match and pd.notna(contact_match.get('agriculture_officer')):
+                        contact_parts.append(f"Agriculture Officer at {contact_match['agriculture_officer']}")
+                    if 'kvk_contact' in contact_match and pd.notna(contact_match.get('kvk_contact')):
+                        contact_parts.append(f"KVK at {contact_match['kvk_contact']}")
+                    if 'kisan_call_center' in contact_match and pd.notna(contact_match.get('kisan_call_center')):
+                        contact_parts.append(f"Kisan Call Center at {contact_match['kisan_call_center']}")
+                    if contact_parts:
+                        contact_info = f"For detailed advice in {state}, contact: " + " or ".join(contact_parts) + "."
+
+        if not advisory:
+            if crop_name and crop_name.lower() == "wheat" and issue_type == "pest":
+                advisory = "For wheat pest control: If you see aphids, spray Imidacloprid 200 SL at 0.3ml per liter of water. Spray during evening hours. Avoid over-irrigation."
+            elif crop_name and crop_name.lower() == "rice" and issue_type == "disease":
+                advisory = "For rice disease management: If you see brown spots on leaves, it might be blast disease. Apply Tricyclazole 75% WP at 0.6g per liter. Ensure proper drainage."
+            else:
+                advisory = f"For {crop_name or 'the crop'} at {growth_stage or 'current'} stage: Monitor crop regularly, maintain proper spacing, apply fertilizers as per soil test recommendations."
+
+        if not contact_info:
+            contact_info = f"For detailed advice, contact your local Krishi Vigyan Kendra or Agriculture Officer in {state or 'your state'}. You can also call the Kisan Call Centre at 1800-1801-551."
 
+        result_text = f"{advisory} {contact_info}"
+        return {
+            "result": result_text,
+            "recommendations": advisory,
+            "contact_info": contact_info
+        }
+
+    except Exception as e:
+        return {
+            "result": "I couldn't provide specific advice right now. Please contact your local agriculture extension officer.",
+            "error": str(e)
+        }
+
+# -------------------------
+# Run server (for local dev)
+# -------------------------
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", 7860)))