code pushed'

.gitignore

@@ -0,0 +1 @@
+.env

Dockerfile

@@ -0,0 +1,18 @@
+# Base image
+FROM python:3.11-slim
+
+# Set work directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Expose the port Hugging Face expects
+EXPOSE 7860
+
+# Command to run FastAPI with uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

ageents/advisoryAgent.py

@@ -0,0 +1,346 @@
+"""
+Advisory Agent - Transforms raw predictions into farmer-friendly advice
+Location: agents/advisoryAgent.py
+"""
+
+import os
+import json
+import asyncio
+from dotenv import load_dotenv, find_dotenv
+from pydantic import BaseModel
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from agents import (
+    Agent,
+    Runner,
+    AsyncOpenAI,
+    OpenAIChatCompletionsModel,
+    set_tracing_disabled,
+    SQLiteSession,
+    AgentOutputSchema,
+)
+
+from ageents.predictionAgent import run_prediction_workflow
+
+# ---------------- Setup ----------------
+load_dotenv(find_dotenv())
+set_tracing_disabled(True)
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if not GEMINI_API_KEY:
+    raise RuntimeError("Missing Gemini API key in .env -> GEMINI_API_KEY")
+
+client_provider = AsyncOpenAI(
+    api_key=GEMINI_API_KEY,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+Model = OpenAIChatCompletionsModel(
+    model="gemini-2.0-flash",
+    openai_client=client_provider,
+)
+
+runner = Runner()
+
+# ---------------- Output Schema ----------------
+class AdvisoryOutput(BaseModel):
+    """Farmer-friendly advisory response"""
+    
+    # Header
+    farm_name: str
+    advisory_date: str
+    advisory_id: str
+    
+    # Status Overview (Simple, visual)
+    status_emoji: str  # 🟢 🟡 🔴
+    status_message: str  # "Everything looks great!" or "Attention needed"
+    confidence_level: str  # "High", "Moderate", "Low"
+    
+    # Plain Language Summary
+    situation_summary: str  # 2-3 sentences explaining current conditions
+    what_it_means: str  # What this means for your farm in simple terms
+    
+    # Priority Actions (Grouped by urgency)
+    urgent_today: List[str]  # Must do today/tomorrow
+    this_week: List[str]  # Should do this week
+    plan_ahead: List[str]  # Long-term planning
+    
+    # Weather Guidance
+    weather_outlook: str  # Simple weather explanation
+    weather_impact: str  # How weather affects your crop
+    weather_tips: List[str]  # Specific weather-related actions
+    
+    # Soil & Nutrition Guidance
+    soil_health_status: str  # Simple soil health explanation
+    nutrition_advice: str  # What to feed your crops
+    soil_tips: List[str]  # Specific soil-related actions
+    
+    # Water Management
+    irrigation_guidance: str  # When and how much to water
+    water_saving_tips: List[str]  # Optional efficiency tips
+    
+    # Pest & Disease Alert
+    pest_risk_level: str  # "Low", "Moderate", "High"
+    pest_advice: str  # What to watch for
+    prevention_steps: List[str]  # How to prevent issues
+    
+    # Harvest Planning
+    harvest_readiness: str  # "Not yet", "Soon", "Ready"
+    harvest_timing: str  # When to harvest
+    harvest_tips: List[str]  # Pre-harvest checklist
+    
+    # Economic Insights
+    yield_expectation: str  # Expected yield in simple terms
+    cost_saving_opportunities: List[str]  # Ways to save money
+    market_advice: Optional[str]  # When to sell (if applicable)
+    
+    # Success Factors
+    what_going_well: List[str]  # Positive aspects
+    areas_to_improve: List[str]  # Improvement opportunities
+    
+    # Resources & Support
+    helpful_resources: List[str]  # Links to guides, videos, etc.
+    contact_support: str  # When to contact extension office
+    
+    # Next Steps Summary
+    next_advisory_date: str  # When to check back
+    key_reminders: List[str]  # 3-5 most important things to remember
+
+# ---------------- Advisory Agent ----------------
+advisory_agent = Agent(
+    name="FarmerAdvisoryAgent",
+    model=Model,
+    instructions="""
+You are an Agricultural Advisory Agent for farmers. Your role is to translate technical prediction data into clear, actionable, farmer-friendly advice.
+
+Input: Raw prediction data with weather, soil, and risk information (JSON)
+
+Your task:
+1. Write in simple, conversational language (8th-grade reading level)
+2. Use emojis strategically for visual clarity (🌱 ☀️ 💧 ⚠️ ✅)
+3. Group actions by urgency and priority
+4. Explain WHY actions are needed, not just WHAT to do
+5. Provide positive encouragement along with warnings
+6. Focus on practical, affordable solutions
+7. Consider resource constraints of small farmers
+8. Use local/regional context when available
+9. Avoid jargon - use everyday language
+10. Make advice specific to the crop and location
+
+Writing style:
+- "Your wheat needs water this week" NOT "Irrigation required at 40mm intervals"
+- "Heavy rain is coming - check drainage" NOT "Precipitation forecast: 75% probability"
+- "Soil nitrogen is low - add urea fertilizer" NOT "N:P:K ratio suboptimal"
+
+Tone: Supportive, practical, conversational, respectful
+
+Output: Strict JSON matching AdvisoryOutput schema
+
+Remember: Farmers are smart and experienced - respect their knowledge while providing new insights.
+""",
+    output_type=AdvisoryOutput,
+)
+
+# ---------------- Helper Functions ----------------
+def generate_advisory_id():
+    """Generate unique advisory ID"""
+    return f"ADV-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+
+def get_status_emoji(risk_level: str) -> str:
+    """Convert risk level to emoji"""
+    mapping = {
+        "low": "🟢",
+        "moderate": "🟡",
+        "high": "🟠",
+        "critical": "🔴"
+    }
+    return mapping.get(risk_level.lower(), "🟡")
+
+def get_status_message(risk_level: str, success_probability: float) -> str:
+    """Generate status message"""
+    if risk_level == "low" and success_probability > 75:
+        return "Everything looks great! Keep up the good work."
+    elif risk_level == "moderate":
+        return "Attention needed in some areas, but manageable."
+    elif risk_level == "high":
+        return "Important actions required soon."
+    else:
+        return "Urgent attention needed - take action immediately."
+
+def simplify_technical_language(text: str) -> str:
+    """Convert technical terms to simple language"""
+    replacements = {
+        "precipitation": "rain",
+        "irrigation": "watering",
+        "fertilization": "feeding crops",
+        "pathogen": "disease",
+        "nitrogen deficiency": "low nitrogen",
+        "optimal": "best",
+        "implement": "start",
+        "monitor": "check",
+        "facilitate": "help",
+    }
+    
+    result = text
+    for tech, simple in replacements.items():
+        result = result.replace(tech, simple)
+    
+    return result
+
+# ---------------- Main Advisory Function ----------------
+async def run_advisory_agent(location: str, crop: str, city: Optional[str] = None):
+    """
+    Generate farmer-friendly advisory from prediction data
+    """
+    
+    print("\n" + "="*70)
+    print("📋 GENERATING FARMER ADVISORY")
+    print("="*70)
+    print(f"📍 Location: {location}")
+    print(f"🌾 Crop: {crop}")
+    print(f"⏰ Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("="*70 + "\n")
+    
+    # Step 1: Get raw prediction data
+    try:
+        prediction_data = await run_prediction_workflow(location, crop, city)
+    except Exception as e:
+        print(f"❌ Failed to get prediction data: {e}")
+        return {"error": f"Prediction failed: {str(e)}"}
+    
+    if "error" in prediction_data:
+        return prediction_data
+    
+    # Step 2: Prepare message for advisory agent
+    advisory_context = {
+        "prediction_data": prediction_data,
+        "location": location,
+        "crop": crop,
+        "advisory_id": generate_advisory_id(),
+        "generation_time": datetime.now().isoformat()
+    }
+    
+    message = json.dumps(advisory_context, ensure_ascii=False)
+    
+    # Step 3: Run advisory agent
+    print("🤖 Generating farmer-friendly advisory...\n")
+    try:
+        resp = await runner.run(
+            advisory_agent,
+            message,
+            session=SQLiteSession("trace.db")
+        )
+        
+        if hasattr(resp, "output"):
+            advisory_output = resp.output.model_dump()
+        elif hasattr(resp, "final_output"):
+            advisory_output = resp.final_output.model_dump()
+        else:
+            advisory_output = None
+    except Exception as e:
+        print(f"❌ Advisory agent failed: {e}")
+        advisory_output = None
+    
+    # Step 4: Fallback if agent fails
+    if not advisory_output:
+        print("⚠️  Agent failed, generating fallback advisory...\n")
+        
+        risk_level = prediction_data.get("risk_level", "moderate")
+        success_prob = prediction_data.get("success_probability", 70.0)
+        
+        advisory_output = {
+            "farm_name": location,
+            "advisory_date": datetime.now().strftime("%B %d, %Y"),
+            "advisory_id": generate_advisory_id(),
+            
+            "status_emoji": get_status_emoji(risk_level),
+            "status_message": get_status_message(risk_level, success_prob),
+            "confidence_level": "Moderate" if success_prob > 60 else "Low",
+            
+            "situation_summary": simplify_technical_language(
+                prediction_data.get("executive_summary", "Conditions are being analyzed for your farm.")
+            ),
+            "what_it_means": f"Your {crop} crop has a {success_prob}% chance of success. {get_status_message(risk_level, success_prob)}",
+            
+            "urgent_today": [simplify_technical_language(a) for a in prediction_data.get("immediate_actions", [])[:3]],
+            "this_week": [simplify_technical_language(a) for a in prediction_data.get("short_term_actions", [])[:3]],
+            "plan_ahead": [simplify_technical_language(a) for a in prediction_data.get("long_term_actions", [])[:3]],
+            
+            "weather_outlook": f"Rain chance: {prediction_data.get('weather_summary', {}).get('precipitation_chance', 0)}%",
+            "weather_impact": "Weather conditions will affect your watering needs.",
+            "weather_tips": prediction_data.get("weather_risks", [])[:3],
+            
+            "soil_health_status": f"Soil health score: {prediction_data.get('soil_summary', {}).get('health_score', 'N/A')}/100",
+            "nutrition_advice": "Follow the fertilizer schedule below.",
+            "soil_tips": prediction_data.get("soil_risks", [])[:3],
+            
+            "irrigation_guidance": prediction_data.get("irrigation_schedule", {}).get("frequency", "Check soil moisture daily"),
+            "water_saving_tips": ["Use drip irrigation", "Water early morning", "Mulch to retain moisture"],
+            
+            "pest_risk_level": prediction_data.get("pest_disease_risk", "Monitor regularly"),
+            "pest_advice": "Watch for early signs of pests or disease.",
+            "prevention_steps": ["Inspect crops weekly", "Remove affected plants", "Keep field clean"],
+            
+            "harvest_readiness": "Monitor crop maturity",
+            "harvest_timing": prediction_data.get("optimal_harvest_window", "Follow crop maturity indicators"),
+            "harvest_tips": ["Check moisture content", "Prepare storage", "Plan labor needs"],
+            
+            "yield_expectation": prediction_data.get("yield_forecast", "Moderate yield expected"),
+            "cost_saving_opportunities": ["Optimize fertilizer use", "Efficient irrigation", "Preventive pest control"],
+            "market_advice": prediction_data.get("market_timing_advice"),
+            
+            "what_going_well": prediction_data.get("weather_opportunities", []) + prediction_data.get("soil_opportunities", []),
+            "areas_to_improve": [f"Address {risk}" for risk in (prediction_data.get("weather_risks", []) + prediction_data.get("soil_risks", []))[:3]],
+            
+            "helpful_resources": [
+                "Contact local agricultural extension office",
+                "Check weather forecasts daily",
+                "Join farmer WhatsApp groups"
+            ],
+            "contact_support": "Contact support if you see unusual crop symptoms or need urgent help.",
+            
+            "next_advisory_date": "Check back in 3-5 days for updated conditions",
+            "key_reminders": [
+                f"Risk level: {risk_level}",
+                f"Success probability: {success_prob}%",
+                "Follow urgent actions first"
+            ]
+        }
+    
+    # Step 5: Display advisory
+    print("="*70)
+    print(f"📋 FARMER ADVISORY - {advisory_output.get('advisory_date')}")
+    print("="*70)
+    print(f"{advisory_output.get('status_emoji')} STATUS: {advisory_output.get('status_message')}")
+    print(f"\n📊 SITUATION:")
+    print(f"  {advisory_output.get('situation_summary')}")
+    print(f"\n💡 WHAT IT MEANS:")
+    print(f"  {advisory_output.get('what_it_means')}")
+    print(f"\n🔴 URGENT (Do Today/Tomorrow):")
+    for action in advisory_output.get('urgent_today', [])[:3]:
+        print(f"  • {action}")
+    print(f"\n📅 THIS WEEK:")
+    for action in advisory_output.get('this_week', [])[:3]:
+        print(f"  • {action}")
+    print(f"\n💧 WATERING:")
+    print(f"  {advisory_output.get('irrigation_guidance')}")
+    print(f"\n🐛 PEST RISK: {advisory_output.get('pest_risk_level')}")
+    print(f"  {advisory_output.get('pest_advice')}")
+    print("="*70 + "\n")
+    
+    return advisory_output
+
+# ---------------- Standalone Execution ----------------
+if __name__ == "__main__":
+    print("📋 AgriLedger+ Farmer Advisory Agent")
+    print("=" * 70)
+    
+    location_input = input("Enter farm location: ")
+    crop_input = input("Enter crop name: ")
+    city_input = input("Enter city for weather (press Enter to use location): ").strip() or None
+    
+    result = asyncio.run(run_advisory_agent(location_input, crop_input, city_input))
+    
+    print("\n📄 Full Advisory JSON:")
+    print(json.dumps(result, indent=2, ensure_ascii=False))

ageents/ledgerAgent.py

@@ -0,0 +1,91 @@
+import os
+import uuid
+from datetime import datetime
+from pydantic import BaseModel, Field
+from typing import Optional
+from openai import AsyncOpenAI
+from agents import Agent, function_tool, Runner, trace, OpenAIChatCompletionsModel , RunConfig
+from firebase_config import get_db_ref 
+from models.expense import EntryCreate, EntryResponse
+from dotenv import load_dotenv
+
+from openai import AsyncOpenAI
+from agents import Agent, Runner, RunContextWrapper, function_tool, trace
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+# -------------------- MODEL PROVIDER --------------------
+gemini_api_key = os.getenv("GEMINI_API_KEY")
+provider = AsyncOpenAI(
+    api_key=gemini_api_key,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+model = OpenAIChatCompletionsModel(
+    model="gemini-2.5-flash",
+    openai_client=provider,
+)
+config = RunConfig(
+    model=model, model_provider=provider, tracing_disabled=False
+)
+
+# ============================
+# 🔹 FUNCTION TOOL
+# ============================
+
+@function_tool()
+def add_ledger_entry(entry: EntryCreate) -> EntryResponse:
+    """
+    Add a ledger entry to Firebase using UUID for ID.
+    Collection name: 'ledger_entries'
+    """
+
+    # 🧾 Generate ID + Timestamp
+    entry_id = str(uuid.uuid4())
+    created_at = entry.date or datetime.utcnow().isoformat()
+
+    # 🗂 Prepare entry data
+    entry_data = {
+        "entryType": entry.entryType,
+        "category": entry.category,
+        "amount": entry.amount,
+        "currency": entry.currency,
+        "paymentMethod": entry.paymentMethod,
+        "notes": entry.notes,
+        "createdAt": created_at,
+        "recordedBy": entry.recordedBy,
+        "deviceId": entry.deviceId,
+        "syncStatus": "synced",
+        "meta": entry.meta.dict() if entry.meta else None,
+    }
+
+    # 🔥 Save to Firebase (collection auto create)
+    db_ref = get_db_ref("ledger_entries")
+    db_ref.child(entry_id).set(entry_data)
+
+    # 📦 Return structured response
+    return EntryResponse(
+        id=entry_id,
+        entryType=entry.entryType,
+        category=entry.category,
+        amount=entry.amount,
+        currency=entry.currency,
+        paymentMethod=entry.paymentMethod,
+        notes=entry.notes,
+        createdAt=created_at,
+        recordedBy=entry.recordedBy,
+        deviceId=entry.deviceId,
+        meta=entry.meta,
+    )
+
+# ============================
+# 🔹 AGENT DEFINITION
+# ============================
+
+ledger_agent = Agent(
+    name="LedgerAgent",
+    instructions="You record user income or expense entries into Firebase using add_ledger_entry tool.",
+    tools=[add_ledger_entry],
+    
+)

ageents/marketAdvisoryAgent.py

@@ -0,0 +1,483 @@
+"""
+Market Advisory Agent - Transforms raw market data into farmer-friendly advice
+Location: ageents/marketAdvisoryAgent.py
+"""
+
+import os
+import json
+import asyncio
+from dotenv import load_dotenv, find_dotenv
+from pydantic import BaseModel
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from agents import (
+    Agent,
+    Runner,
+    AsyncOpenAI,
+    OpenAIChatCompletionsModel,
+    set_tracing_disabled,
+    SQLiteSession,
+    AgentOutputSchema,
+)
+
+from ageents.marketAgent import get_market_advice
+
+# ---------------- Setup ----------------
+load_dotenv(find_dotenv())
+set_tracing_disabled(True)
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if not GEMINI_API_KEY:
+    raise RuntimeError("Missing Gemini API key in .env -> GEMINI_API_KEY")
+
+client_provider = AsyncOpenAI(
+    api_key=GEMINI_API_KEY,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+Model = OpenAIChatCompletionsModel(
+    model="gemini-2.0-flash",
+    openai_client=client_provider,
+)
+
+runner = Runner()
+
+# ---------------- Output Schema ----------------
+class MarketAdvisoryOutput(BaseModel):
+    """Farmer-friendly market advisory response"""
+    
+    # Header
+    crop: str
+    advisory_date: str
+    advisory_id: str
+    
+    # Quick Decision
+    decision_emoji: str  # 💰 (sell) 🛒 (buy) ⏳ (wait) 🔄 (hold)
+    main_action: str  # "Sell Now", "Wait for Better Prices", "Good Time to Buy Inputs"
+    urgency_level: str  # "urgent", "soon", "no_rush", "flexible"
+    
+    # Simple Explanation
+    what_happening: str  # Plain language: what's going on in the market
+    why_it_matters: str  # How this affects your money/farm
+    best_move: str  # What you should do and why
+    
+    # Price Information (Simple)
+    current_price_pkr: float
+    price_direction: str  # "going up", "going down", "staying same"
+    price_change_description: str  # "Increased by 150 rupees in 7 days"
+    is_good_price: bool  # True if it's a good selling price
+    
+    # Timing Advice
+    when_to_act: str  # "This week", "Within 2 weeks", "No rush", "Wait 1 month"
+    seasonal_advice: str  # What season means for prices
+    upcoming_events: List[str]  # Things that might change prices soon
+    
+    # Money Talk (Practical)
+    expected_income_per_acre: Optional[str]  # "15,000 to 20,000 rupees per acre"
+    profit_potential: str  # "Good profit expected", "Break even", "Low profit"
+    price_forecast_simple: str  # "Likely to rise", "May drop soon", "Should stay stable"
+    
+    # Action Steps
+    do_today: List[str]  # Immediate actions
+    do_this_week: List[str]  # Short-term actions
+    plan_ahead: List[str]  # Future planning
+    
+    # Risk Warnings
+    risks_to_watch: List[str]  # What could go wrong
+    how_to_protect: List[str]  # How to reduce risks
+    
+    # Alternative Options
+    if_cant_sell_now: List[str]  # What if you can't sell right away
+    other_opportunities: List[str]  # Other ways to make money from this crop
+    
+    # Market Context (Simple)
+    supply_situation: str  # "High supply", "Normal", "Low supply"
+    demand_situation: str  # "High demand", "Normal", "Low demand"
+    competition_level: str  # "Many sellers", "Normal", "Few sellers"
+    
+    # Practical Tips
+    selling_tips: List[str]  # How to get best price when selling
+    buying_tips: List[str]  # How to save money when buying inputs
+    storage_advice: Optional[str]  # If you should store crop instead of selling
+    
+    # Comparison
+    compared_to_last_week: str  # "Prices are 200 rupees higher"
+    compared_to_last_month: str  # "Down from peak of 2,800 rupees"
+    compared_to_normal: str  # "This is above average price"
+    
+    # Transport & Logistics
+    market_access_tips: List[str]  # How to get to market, which market to choose
+    transport_costs: Optional[str]  # Expected transport costs
+    
+    # Negotiation Help
+    fair_price_range: str  # "2,400 to 2,600 rupees per 40kg"
+    dont_sell_below: float  # Minimum acceptable price
+    aim_to_sell_at: float  # Target selling price
+    
+    # Community Info
+    what_neighbors_doing: Optional[str]  # What other farmers are doing
+    cooperative_opportunities: List[str]  # Benefits of selling together
+    
+    # Resources
+    where_to_check_prices: List[str]  # Where to verify current prices
+    who_to_contact: List[str]  # Extension office, buyer contacts
+    
+    # Summary
+    bottom_line: str  # One-sentence takeaway
+    confidence_level: str  # "Very confident", "Fairly confident", "Uncertain"
+
+# ---------------- Market Advisory Agent ----------------
+market_advisory_agent = Agent(
+    name="FarmerMarketAdvisoryAgent",
+    model=Model,
+    instructions="""
+You are a Market Advisory Agent for Pakistani farmers. Transform technical market analysis into practical, money-focused advice.
+
+Input: Raw market analysis with prices, trends, and technical data
+
+Your task:
+1. Translate market data into simple rupee amounts and percentages
+2. Give clear YES/NO/WAIT advice on selling or buying
+3. Explain market conditions like you're talking to a neighbor
+4. Focus on MONEY - how much they can earn or save
+5. Provide specific timing advice - "this week", "wait 2 weeks", etc.
+6. Consider farmer's practical constraints (transport, storage, immediate cash needs)
+7. Use local context - Pakistani markets, seasonal patterns, religious holidays
+8. Give negotiation tips - minimum price to accept, target price to aim for
+
+Writing style:
+- "Sell now - prices are 200 rupees higher than last week" NOT "Upward trend of 8.3%"
+- "You can earn 15,000-20,000 rupees per acre" NOT "ROI improvement observed"
+- "Wait 2 weeks - harvest season will bring more buyers" NOT "Market dynamics suggest delayed transaction"
+- "Don't sell below 2,400 rupees per bag" NOT "Maintain price floor at modal rate"
+
+Money focus:
+- Always convert percentages to actual rupee amounts
+- Show expected income per acre when possible
+- Compare to costs - "Price covers fertilizer + labor costs with 30% profit"
+- Mention break-even points - "You need at least 2,200 rupees to cover costs"
+
+Practical considerations:
+- Transport costs (50-100 rupees per bag typical)
+- Market timing (avoid selling Friday afternoon during prayer time)
+- Storage options (if prices might rise soon)
+- Bulk selling benefits (better price when selling with neighbors)
+- Seasonal festivals (Eid, weddings increase demand for certain crops)
+
+Tone: Friendly neighbor, practical businessman, supportive advisor
+
+Output: Strict JSON matching MarketAdvisoryOutput schema
+""",
+    output_type=AgentOutputSchema(MarketAdvisoryOutput, strict_json_schema=False),
+)
+
+# ---------------- Helper Functions ----------------
+def generate_market_advisory_id():
+    """Generate unique market advisory ID"""
+    return f"MKT-ADV-{datetime.now().strftime('%Y%m%d-%H%M%S')}"
+
+def get_decision_emoji(action: str) -> str:
+    """Get emoji based on main action"""
+    action_lower = action.lower()
+    if "sell" in action_lower and "now" in action_lower:
+        return "💰"
+    elif "buy" in action_lower:
+        return "🛒"
+    elif "wait" in action_lower:
+        return "⏳"
+    else:
+        return "🔄"
+
+def extract_price_from_advice(raw_advice: str) -> float:
+    """Extract current price from raw market advice"""
+    import re
+    # Look for patterns like "₨2,500" or "PKR 2500"
+    matches = re.findall(r'[₨PKR\s]*(\d{1,3}(?:,\d{3})*(?:\.\d{2})?)', raw_advice)
+    if matches:
+        # Take first number that looks like a price (usually 1000+)
+        for match in matches:
+            price = float(match.replace(',', ''))
+            if price > 100:  # Reasonable crop price
+                return price
+    return 0.0
+
+def simplify_trend(trend_text: str) -> dict:
+    """Convert technical trend to simple description"""
+    trend_lower = trend_text.lower()
+    
+    if "rising" in trend_lower or "increase" in trend_lower or "up" in trend_lower:
+        return {
+            "direction": "going up",
+            "is_good": True,
+            "simple": "Prices are rising - good for sellers!"
+        }
+    elif "falling" in trend_lower or "decrease" in trend_lower or "down" in trend_lower:
+        return {
+            "direction": "going down",
+            "is_good": False,
+            "simple": "Prices are dropping - not ideal for selling now"
+        }
+    else:
+        return {
+            "direction": "staying same",
+            "is_good": None,
+            "simple": "Prices are stable - no rush to decide"
+        }
+
+# ---------------- Main Advisory Function ----------------
+async def run_market_advisory(crop: str, farmer_context: Optional[Dict] = None):
+    """
+    Generate farmer-friendly market advisory
+    """
+    
+    print("\n" + "="*70)
+    print("💰 GENERATING MARKET ADVISORY")
+    print("="*70)
+    print(f"🌾 Crop: {crop.upper()}")
+    if farmer_context:
+        print(f"👨‍🌾 Farmer Context: {farmer_context}")
+    print(f"⏰ Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("="*70 + "\n")
+    
+    # Step 1: Get raw market analysis from market agent
+    try:
+        raw_advice = await get_market_advice(crop.lower(), farmer_context)
+    except Exception as e:
+        print(f"❌ Failed to get market data: {e}")
+        return {"error": f"Market data unavailable: {str(e)}"}
+    
+    if not raw_advice or "ERROR" in raw_advice:
+        return {"error": "Market analysis failed or database not seeded"}
+    
+    # Step 2: Prepare context for advisory agent
+    advisory_context = {
+        "crop": crop,
+        "raw_market_analysis": raw_advice,
+        "farmer_context": farmer_context or {},
+        "advisory_id": generate_market_advisory_id(),
+        "generation_time": datetime.now().isoformat()
+    }
+    
+    message = json.dumps(advisory_context, ensure_ascii=False)
+    
+    # Step 3: Run market advisory agent
+    print("🤖 Transforming market data into farmer advice...\n")
+    try:
+        resp = await runner.run(
+            market_advisory_agent,
+            message,
+            session=SQLiteSession("trace.db")
+        )
+        
+        if hasattr(resp, "output"):
+            advisory_output = resp.output.model_dump()
+        elif hasattr(resp, "final_output"):
+            advisory_output = resp.final_output.model_dump()
+        else:
+            advisory_output = None
+    except Exception as e:
+        print(f"❌ Market advisory agent failed: {e}")
+        advisory_output = None
+    
+    # Step 4: Fallback if agent fails
+    if not advisory_output:
+        print("⚠️  Agent failed, generating fallback advisory...\n")
+        
+        # Extract basic info from raw advice
+        current_price = extract_price_from_advice(raw_advice)
+        
+        # Determine main action from raw advice
+        if "SELL NOW" in raw_advice.upper():
+            main_action = "Sell Now"
+            urgency = "urgent"
+            emoji = "💰"
+        elif "BUY" in raw_advice.upper():
+            main_action = "Good Time to Buy Inputs"
+            urgency = "soon"
+            emoji = "🛒"
+        elif "WAIT" in raw_advice.upper():
+            main_action = "Wait for Better Prices"
+            urgency = "flexible"
+            emoji = "⏳"
+        else:
+            main_action = "Hold and Monitor"
+            urgency = "no_rush"
+            emoji = "🔄"
+        
+        advisory_output = {
+            "crop": crop,
+            "advisory_date": datetime.now().strftime("%B %d, %Y"),
+            "advisory_id": generate_market_advisory_id(),
+            
+            "decision_emoji": emoji,
+            "main_action": main_action,
+            "urgency_level": urgency,
+            
+            "what_happening": f"Market analysis shows current prices for {crop}.",
+            "why_it_matters": "Price movements affect your potential earnings from selling or costs for buying inputs.",
+            "best_move": main_action,
+            
+            "current_price_pkr": current_price if current_price > 0 else 0.0,
+            "price_direction": "Check raw analysis for details",
+            "price_change_description": "Price trend data available in detailed analysis",
+            "is_good_price": "SELL" in main_action,
+            
+            "when_to_act": "Within 1 week" if urgency == "urgent" else "Within 2-3 weeks" if urgency == "soon" else "Monitor market",
+            "seasonal_advice": f"Consider seasonal patterns for {crop} in your region",
+            "upcoming_events": ["Monitor local market conditions", "Check weather forecasts"],
+            
+            "expected_income_per_acre": "Consult local buyers for current rates",
+            "profit_potential": "Depends on your production costs",
+            "price_forecast_simple": "Based on current trend: " + main_action,
+            
+            "do_today": [
+                f"Check current {crop} prices at your local market",
+                "Calculate your break-even price (costs + transport)",
+                "Contact 2-3 buyers to compare offers"
+            ],
+            
+            "do_this_week": [
+                "Monitor price changes daily",
+                "Prepare crop for market (cleaning, grading)",
+                "Arrange transport if selling"
+            ],
+            
+            "plan_ahead": [
+                f"Track {crop} price patterns for future planning",
+                "Consider storage options for better timing",
+                "Join farmer cooperative for better prices"
+            ],
+            
+            "risks_to_watch": [
+                "Sudden price drops if oversupply",
+                "Weather affecting transport",
+                "Quality deterioration if stored too long"
+            ],
+            
+            "how_to_protect": [
+                "Don't wait too long if advised to sell",
+                "Store properly if holding crop",
+                "Have backup buyers identified"
+            ],
+            
+            "if_cant_sell_now": [
+                "Ensure proper storage facilities",
+                "Monitor prices weekly",
+                "Consider partial selling (sell some, hold some)"
+            ],
+            
+            "other_opportunities": [
+                "Direct sale to consumers (better margin)",
+                "Contract farming for next season",
+                "Value addition (processing, packaging)"
+            ],
+            
+            "supply_situation": "Check with local traders",
+            "demand_situation": "Monitor market activity",
+            "competition_level": "Observe number of sellers at market",
+            
+            "selling_tips": [
+                "Sell early in morning for better prices",
+                "Grade your crop properly",
+                "Don't accept first offer - negotiate",
+                "Sell in bulk with neighbors for better rate"
+            ],
+            
+            "buying_tips": [
+                "Buy inputs off-season for lower prices",
+                "Purchase in bulk with cooperative",
+                "Compare suppliers before buying"
+            ],
+            
+            "storage_advice": "Store only if advised to wait and you have proper facilities",
+            
+            "compared_to_last_week": "Check detailed analysis",
+            "compared_to_last_month": "Historical data shows trends",
+            "compared_to_normal": "Current price relative to seasonal average",
+            
+            "market_access_tips": [
+                "Visit market on active trading days (avoid Fridays afternoon)",
+                "Compare prices at 2-3 different markets if possible",
+                "Consider online platforms for price discovery"
+            ],
+            
+            "transport_costs": "Estimate 50-100 rupees per 40kg bag for local transport",
+            
+            "fair_price_range": f"Check current rates - target above {current_price if current_price > 0 else 'market rate'}",
+            "dont_sell_below": current_price * 0.9 if current_price > 0 else 0.0,
+            "aim_to_sell_at": current_price * 1.05 if current_price > 0 else 0.0,
+            
+            "what_neighbors_doing": "Talk to other farmers about their selling plans",
+            "cooperative_opportunities": [
+                "Better prices through bulk selling",
+                "Shared transport costs",
+                "Collective bargaining power"
+            ],
+            
+            "where_to_check_prices": [
+                "Local agricultural market",
+                "District agriculture office",
+                "Online price portals",
+                "SMS price services"
+            ],
+            
+            "who_to_contact": [
+                "District Agriculture Extension Officer",
+                "Local market committee",
+                "Farmer cooperatives"
+            ],
+            
+            "bottom_line": main_action + " - Monitor market closely and act based on your cash needs.",
+            "confidence_level": "Fairly confident based on available data"
+        }
+    
+    # Step 5: Display advisory
+    print("="*70)
+    print(f"💰 MARKET ADVISORY - {advisory_output.get('crop', crop).upper()}")
+    print("="*70)
+    print(f"{advisory_output.get('decision_emoji')} DECISION: {advisory_output.get('main_action')}")
+    print(f"⚡ Urgency: {advisory_output.get('urgency_level').upper()}")
+    print(f"\n💵 CURRENT PRICE: ₨{advisory_output.get('current_price_pkr', 0):,.2f} per 40kg")
+    print(f"📊 PRICE TREND: {advisory_output.get('price_direction')}")
+    print(f"\n💡 WHAT'S HAPPENING:")
+    print(f"  {advisory_output.get('what_happening')}")
+    print(f"\n🎯 BEST MOVE:")
+    print(f"  {advisory_output.get('best_move')}")
+    print(f"\n📅 WHEN TO ACT: {advisory_output.get('when_to_act')}")
+    print(f"\n✅ DO TODAY:")
+    for action in advisory_output.get('do_today', [])[:3]:
+        print(f"  • {action}")
+    print(f"\n⚠️ RISKS TO WATCH:")
+    for risk in advisory_output.get('risks_to_watch', [])[:3]:
+        print(f"  • {risk}")
+    print(f"\n💬 BOTTOM LINE:")
+    print(f"  {advisory_output.get('bottom_line')}")
+    print("="*70 + "\n")
+    
+    return advisory_output
+
+# ---------------- Standalone Execution ----------------
+if __name__ == "__main__":
+    print("💰 AgriLedger+ Market Advisory Agent")
+    print("=" * 70)
+    
+    crop_input = input("Enter crop name: ")
+    
+    # Optional farmer context
+    budget_input = input("Enter budget (PKR) [press Enter to skip]: ").strip()
+    land_input = input("Enter land size (acres) [press Enter to skip]: ").strip()
+    risk_input = input("Enter risk tolerance (low/medium/high) [press Enter to skip]: ").strip()
+    
+    farmer_context = {}
+    if budget_input:
+        farmer_context["budget"] = float(budget_input)
+    if land_input:
+        farmer_context["land_size"] = float(land_input)
+    if risk_input:
+        farmer_context["risk_tolerance"] = risk_input
+    
+    result = asyncio.run(run_market_advisory(crop_input, farmer_context or None))
+    
+    print("\n📄 Full Advisory JSON:")
+    print(json.dumps(result, indent=2, ensure_ascii=False))

ageents/marketAgent.py

@@ -0,0 +1,525 @@
+"""
+Market Agent for AgriLedger+ - Uses Seeded Firebase Data Only
+Fixed version with proper tool implementation
+"""
+
+import os
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Any
+from dotenv import load_dotenv
+from firebase_config import get_db_ref
+from agents import Agent, function_tool, OpenAIChatCompletionsModel, Runner
+from openai import AsyncOpenAI
+import statistics
+
+load_dotenv()
+
+# -------------------- MODEL PROVIDER --------------------
+gemini_api_key = os.getenv("GEMINI_API_KEY")
+provider = AsyncOpenAI(
+    api_key=gemini_api_key,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+model = OpenAIChatCompletionsModel(
+    model="gemini-2.5-flash",
+    openai_client=provider,
+)
+
+# -------------------- CONSTANTS --------------------
+VOLATILITY_THRESHOLD = 5.0
+SIGNIFICANT_CHANGE = 10.0
+
+# Pakistan crop seasons
+PAKISTAN_CROP_SEASONS = {
+    "wheat": {"plant": [10, 11, 12], "harvest": [4, 5]},
+    "rice": {"plant": [5, 6, 7], "harvest": [10, 11]},
+    "maize": {"plant": [2, 3, 7, 8], "harvest": [6, 11]},
+    "cotton": {"plant": [4, 5, 6], "harvest": [9, 10, 11]},
+    "sugarcane": {"plant": [9, 10, 11], "harvest": [11, 12, 1, 2]},
+    "potato": {"plant": [1, 2, 9, 10], "harvest": [4, 5, 11, 12]},
+    "onion": {"plant": [10, 11, 12], "harvest": [3, 4, 5]},
+    "tomato": {"plant": [1, 2, 7, 8], "harvest": [5, 6, 11, 12]},
+}
+
+# -------------------- IMPLEMENTATION FUNCTIONS --------------------
+# These are the actual implementations that do the work
+
+def get_current_prices_impl(crop: Optional[str] = None) -> dict[str, Any]:
+    """Get current market prices from Firebase seeded data"""
+    try:
+        latest_ref = get_db_ref("market_data/latest")
+        latest_data = latest_ref.get()
+        
+        if not latest_data:
+            prices_ref = get_db_ref("market_data/prices")
+            all_prices = prices_ref.get() or {}
+            
+            if not all_prices:
+                return {"error": "No market data found. Database needs to be seeded.", "requires_seeding": True}
+            
+            latest_prices = {}
+            for crop_name, dates in all_prices.items():
+                if isinstance(dates, dict):
+                    sorted_dates = sorted(dates.keys(), reverse=True)
+                    if sorted_dates:
+                        recent_date = sorted_dates[0]
+                        recent_entries = dates[recent_date]
+                        if isinstance(recent_entries, dict):
+                            prices = [e["modal_price"] for e in recent_entries.values() if "modal_price" in e]
+                            if prices:
+                                latest_prices[crop_name] = round(sum(prices) / len(prices), 2)
+            
+            if latest_prices:
+                latest_ref.set({
+                    "prices": latest_prices,
+                    "timestamp": datetime.now().isoformat(),
+                    "status": "computed",
+                    "source": "seeded_data"
+                })
+                latest_data = {
+                    "prices": latest_prices,
+                    "timestamp": datetime.now().isoformat()
+                }
+        
+        if crop:
+            price = latest_data.get("prices", {}).get(crop)
+            if not price:
+                available = list(latest_data.get("prices", {}).keys())
+                return {
+                    "error": f"No price data for {crop}",
+                    "available_crops": available,
+                    "suggestion": f"Try one of: {', '.join(available[:5])}"
+                }
+            return {
+                "crop": crop,
+                "price": price,
+                "timestamp": latest_data.get("timestamp"),
+                "source": "firebase_seeded"
+            }
+        
+        return latest_data
+        
+    except Exception as e:
+        return {"error": f"Firebase error: {str(e)}"}
+
+
+def get_historical_prices_impl(crop: str, days: int = 30) -> dict[str, Any]:
+    """Retrieve historical price data for a specific crop"""
+    try:
+        prices_ref = get_db_ref(f"market_data/prices/{crop}")
+        all_dates = prices_ref.get()
+        
+        if not all_dates:
+            return {
+                "crop": crop,
+                "error": f"No historical data for {crop}. Database may not be seeded.",
+                "data_points": [],
+                "requires_seeding": True
+            }
+        
+        cutoff_date = datetime.now() - timedelta(days=days)
+        price_history = []
+        
+        for date_key, entries in all_dates.items():
+            try:
+                date_obj = datetime.strptime(date_key, "%Y-%m-%d")
+                
+                if date_obj >= cutoff_date:
+                    if isinstance(entries, dict):
+                        prices = []
+                        min_prices = []
+                        max_prices = []
+                        
+                        for entry in entries.values():
+                            if isinstance(entry, dict) and "modal_price" in entry:
+                                prices.append(entry["modal_price"])
+                                min_prices.append(entry.get("min_price", entry["modal_price"]))
+                                max_prices.append(entry.get("max_price", entry["modal_price"]))
+                        
+                        if prices:
+                            avg_price = sum(prices) / len(prices)
+                            
+                            price_history.append({
+                                "date": date_key,
+                                "timestamp": date_obj.isoformat(),
+                                "modal_price": round(avg_price, 2),
+                                "min_price": round(min(min_prices), 2),
+                                "max_price": round(max(max_prices), 2),
+                                "entries_count": len(prices)
+                            })
+            except ValueError:
+                continue
+            except Exception:
+                continue
+        
+        price_history.sort(key=lambda x: x["date"])
+        
+        if len(price_history) == 0:
+            return {
+                "crop": crop,
+                "error": "No data points in requested date range",
+                "data_points": [],
+                "suggestion": "Try seeding more data or increasing days parameter"
+            }
+        
+        return {
+            "crop": crop,
+            "days_requested": days,
+            "data_points": price_history,
+            "total_records": len(price_history)
+        }
+        
+    except Exception as e:
+        return {"crop": crop, "error": str(e), "data_points": []}
+
+
+def calculate_price_trend_impl(crop: str, days: int = 7) -> dict[str, Any]:
+    """Analyze price trends and calculate statistics"""
+    try:
+        history = get_historical_prices_impl(crop, days)
+        
+        if history.get("error") or not history.get("data_points"):
+            return {
+                "crop": crop,
+                "trend": "unavailable",
+                "error": history.get("error", "Insufficient data"),
+                "confidence": "none"
+            }
+        
+        data_points = history["data_points"]
+        
+        if len(data_points) < 2:
+            return {
+                "crop": crop,
+                "trend": "unavailable",
+                "error": "Need at least 2 data points for trend analysis",
+                "confidence": "none",
+                "data_points": len(data_points)
+            }
+        
+        prices = [p["modal_price"] for p in data_points]
+        
+        current_price = prices[-1]
+        starting_price = prices[0]
+        percent_change = ((current_price - starting_price) / starting_price) * 100
+        
+        if len(prices) >= 3:
+            price_changes = []
+            for i in range(1, len(prices)):
+                change = abs(((prices[i] - prices[i-1]) / prices[i-1]) * 100)
+                price_changes.append(change)
+            avg_volatility = sum(price_changes) / len(price_changes)
+            volatility_level = "high" if avg_volatility > VOLATILITY_THRESHOLD else "moderate" if avg_volatility > 2 else "low"
+        else:
+            avg_volatility = abs(percent_change)
+            volatility_level = "low"
+        
+        if percent_change > 2:
+            trend = "rising"
+        elif percent_change < -2:
+            trend = "falling"
+        else:
+            trend = "stable"
+        
+        confidence = "high" if len(prices) >= 7 else "medium" if len(prices) >= 4 else "low"
+        
+        avg_7day = sum(prices[-7:]) / min(7, len(prices))
+        avg_30day = sum(prices[-30:]) / min(30, len(prices)) if len(prices) > 7 else None
+        
+        result = {
+            "crop": crop,
+            "trend": trend,
+            "percent_change": round(percent_change, 2),
+            "current_price": round(current_price, 2),
+            "starting_price": round(starting_price, 2),
+            "avg_price_7day": round(avg_7day, 2),
+            "avg_price_30day": round(avg_30day, 2) if avg_30day else None,
+            "volatility": volatility_level,
+            "avg_volatility": round(avg_volatility, 2),
+            "confidence": confidence,
+            "data_points": len(prices),
+            "analysis_period": f"{days} days",
+            "price_range": {
+                "min": round(min(prices), 2),
+                "max": round(max(prices), 2)
+            },
+            "recent_prices": [round(p, 2) for p in prices[-5:]]
+        }
+        
+        return result
+        
+    except Exception as e:
+        return {
+            "crop": crop,
+            "trend": "error",
+            "error": str(e),
+            "confidence": "none"
+        }
+
+
+def get_seasonal_context_impl(crop: str) -> dict[str, Any]:
+    """Get seasonal planting and harvest information"""
+    try:
+        current_month = datetime.now().month
+        
+        if crop not in PAKISTAN_CROP_SEASONS:
+            return {
+                "crop": crop,
+                "seasonal_advice": "No seasonal data available for this crop",
+                "in_planting_season": False,
+                "in_harvest_season": False
+            }
+        
+        seasons = PAKISTAN_CROP_SEASONS[crop]
+        in_planting = current_month in seasons["plant"]
+        in_harvest = current_month in seasons["harvest"]
+        
+        if in_planting:
+            advice = "PLANTING SEASON - High demand for inputs, optimal purchasing time"
+        elif in_harvest:
+            advice = "HARVEST SEASON - Prime selling period, market supply increases"
+        else:
+            advice = "Off-season period"
+        
+        return {
+            "crop": crop,
+            "current_month": current_month,
+            "in_planting_season": in_planting,
+            "in_harvest_season": in_harvest,
+            "seasonal_advice": advice,
+            "plant_months": seasons["plant"],
+            "harvest_months": seasons["harvest"]
+        }
+        
+    except Exception as e:
+        return {
+            "crop": crop,
+            "error": str(e),
+            "seasonal_advice": "Unable to determine seasonal context"
+        }
+
+
+def get_market_statistics_impl(crop: str) -> dict[str, Any]:
+    """Get comprehensive market statistics for a crop"""
+    try:
+        prices_ref = get_db_ref(f"market_data/prices/{crop}")
+        all_data = prices_ref.get() or {}
+        
+        if not all_data:
+            return {"crop": crop, "error": "No data available"}
+        
+        all_prices = []
+        provinces = set()
+        cities = set()
+        
+        for date_key, entries in all_data.items():
+            if isinstance(entries, dict):
+                for entry in entries.values():
+                    if "modal_price" in entry:
+                        all_prices.append(entry["modal_price"])
+                    if "province" in entry:
+                        provinces.add(entry["province"])
+                    if "city" in entry:
+                        cities.add(entry["city"])
+        
+        if not all_prices:
+            return {"crop": crop, "error": "No price data"}
+        
+        return {
+            "crop": crop,
+            "total_entries": len(all_prices),
+            "provinces": list(provinces),
+            "cities": list(cities),
+            "price_statistics": {
+                "min": round(min(all_prices), 2),
+                "max": round(max(all_prices), 2),
+                "average": round(sum(all_prices) / len(all_prices), 2),
+                "median": round(statistics.median(all_prices), 2),
+                "std_deviation": round(statistics.stdev(all_prices), 2) if len(all_prices) > 1 else 0
+            }
+        }
+        
+    except Exception as e:
+        return {"crop": crop, "error": str(e)}
+
+
+# -------------------- TOOL WRAPPERS FOR AGENT --------------------
+# These wrap the implementations for use by the Agent framework
+
+@function_tool
+def get_current_prices(crop: Optional[str] = None) -> dict[str, Any]:
+    """Get current market prices from Firebase seeded data"""
+    return get_current_prices_impl(crop)
+
+
+@function_tool
+def get_historical_prices(crop: str, days: int = 30) -> dict[str, Any]:
+    """Retrieve historical price data for a specific crop"""
+    return get_historical_prices_impl(crop, days)
+
+
+@function_tool
+def calculate_price_trend(crop: str, days: int = 7) -> dict[str, Any]:
+    """Analyze price trends and calculate statistics"""
+    return calculate_price_trend_impl(crop, days)
+
+
+@function_tool
+def get_seasonal_context(crop: str) -> dict[str, Any]:
+    """Get seasonal planting and harvest information"""
+    return get_seasonal_context_impl(crop)
+
+
+@function_tool
+def get_market_statistics(crop: str) -> dict[str, Any]:
+    """Get comprehensive market statistics for a crop"""
+    return get_market_statistics_impl(crop)
+
+
+# -------------------- MARKET AGENT --------------------
+market_agent = Agent(
+    name="MarketAdvisor",
+    instructions="""You are an Expert Agricultural Market Intelligence Agent for Pakistani farmers using REAL SEEDED DATA from Firebase.
+
+🎯 MANDATORY WORKFLOW:
+
+1. ALWAYS call get_current_prices(crop) first
+2. ALWAYS call calculate_price_trend(crop, 7) second
+3. ALWAYS call get_seasonal_context(crop) third
+4. Optionally call get_market_statistics(crop) for deeper insights
+
+If ANY tool returns an error about missing data or "requires_seeding", immediately inform the user that the database needs to be seeded first and stop.
+
+📊 RESPONSE FORMAT (use exactly this structure):
+
+🌾 [CROP NAME] MARKET ADVISORY
+
+**Action:** [SELL NOW / BUY INPUTS / HOLD / WAIT]
+**Current Price:** ₨[X,XXX]/40kg
+**Price Trend:** [rising/falling/stable] by [±X.X]% over 7 days
+**Confidence:** [HIGH/MEDIUM/LOW]
+
+**Market Analysis:**
+• Current Price: ₨[X,XXX] (was ₨[Y,YYY] 7 days ago)
+• Price Change: [+/-]X.X% over analysis period
+• Volatility: [low/moderate/high] market conditions
+• Seasonal Context: [Current month situation]
+• Data Quality: [N] price records analyzed
+
+**Recommendation:**
+[Specific actionable advice based on actual data]
+
+**Risk Factors:**
+• [Specific risk based on trend data]
+• [Specific risk based on seasonality]
+• [Specific risk based on volatility]
+
+💡 DECISION LOGIC:
+- SELL NOW: Harvest season AND (rising >5% OR spike >10%)
+- BUY INPUTS: Planting season AND (falling >5% OR drop >10%)
+- HOLD: Stable prices (<2% change) AND no seasonal pressure
+- WAIT: High volatility (>5%) OR conflicting signals
+
+🔍 DATA RULES:
+1. Use ONLY actual numbers from tool responses
+2. ALWAYS mention percent_change value from calculate_price_trend()
+3. ALWAYS mention data_points count
+4. ALWAYS reference volatility level
+5. Base ALL recommendations on Firebase data
+
+🚫 NEVER:
+- Provide advice without calling calculate_price_trend()
+- Use vague phrases without specific numbers
+- Ignore errors from tools
+- Make up data if tools fail""",
+    model=model,
+    tools=[
+        get_current_prices,
+        get_historical_prices,
+        calculate_price_trend,
+        get_seasonal_context,
+        get_market_statistics
+    ],
+)
+
+# -------------------- RUNNER --------------------
+runner = Runner()
+
+
+async def get_market_advice(crop: str, farmer_data: Optional[Dict[str, Any]] = None) -> str:
+    """Get comprehensive market advice for a specific crop"""
+    
+    prompt = f"""Provide comprehensive market advice for {crop.upper()} using the seeded Firebase data.
+
+CRITICAL: You MUST call these tools in order:
+1. get_current_prices("{crop}")
+2. calculate_price_trend("{crop}", 7)
+3. get_seasonal_context("{crop}")
+
+If any tool returns an error with "requires_seeding" or "No data found", stop immediately and tell the user to seed the database first.
+
+Then provide your complete advisory using the exact format specified in your instructions."""
+    
+    if farmer_data:
+        context = []
+        if farmer_data.get('budget'):
+            context.append(f"budget: PKR {farmer_data['budget']:,}")
+        if farmer_data.get('land_size'):
+            context.append(f"land: {farmer_data['land_size']} acres")
+        if farmer_data.get('risk_tolerance'):
+            context.append(f"risk tolerance: {farmer_data['risk_tolerance']}")
+        
+        if context:
+            prompt += f"\n\nFarmer context: {', '.join(context)}"
+    
+    print(f"\n{'='*60}")
+    print(f"🤖 MARKET AGENT REQUEST: {crop.upper()}")
+    print(f"{'='*60}")
+    
+    try:
+        result = await runner.run(market_agent, prompt)
+        
+        response = None
+        if hasattr(result, "final_output") and result.final_output:
+            response = result.final_output
+        elif hasattr(result, "output") and result.output:
+            response = result.output
+        elif hasattr(result, "messages") and result.messages:
+            for msg in reversed(result.messages):
+                if hasattr(msg, "role") and msg.role == "assistant":
+                    if hasattr(msg, "content") and msg.content:
+                        response = str(msg.content)
+                        break
+        
+        if not response:
+            return f"""🌾 {crop.upper()} MARKET ADVISORY
+
+**Status:** ERROR
+
+Unable to generate advice. The agent did not return a valid response.
+
+**Action Required:**
+1. Ensure database is seeded: POST /admin/seed-market-data
+2. Check Firebase connection
+3. Verify agent configuration
+
+Please seed the database first and try again."""
+        
+        print(f"✅ Market advice generated successfully")
+        return response
+        
+    except Exception as e:
+        print(f"❌ Agent error: {e}")
+        import traceback
+        traceback.print_exc()
+        return f"""🌾 {crop.upper()} MARKET ADVISORY
+
+**Status:** ERROR
+
+Failed to generate market advice: {str(e)}
+
+**Action Required:**
+Ensure the database has been seeded with market data by calling:
+POST /admin/seed-market-data
+
+Then try again."""

ageents/predictionAgent.py

@@ -0,0 +1,534 @@
+"""
+FIXED Prediction Workflow Agent - Synthesizes Weather and Soil data
+Location: ageents/predictionAgent.py
+
+FIX: Added AgentOutputSchema wrapper to handle strict JSON schema validation
+"""
+
+import os
+import json
+import asyncio
+from dotenv import load_dotenv, find_dotenv
+from pydantic import BaseModel
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from agents import (
+    Agent,
+    Runner,
+    AsyncOpenAI,
+    OpenAIChatCompletionsModel,
+    set_tracing_disabled,
+    SQLiteSession,
+    AgentOutputSchema,  # ← ADDED THIS
+)
+
+# Import the specialized agents
+from ageents.weatherAgent import run_weather_agent
+from ageents.soilAgent import run_soil_agent
+
+# ---------------- Setup ----------------
+load_dotenv(find_dotenv())
+set_tracing_disabled(True)
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if not GEMINI_API_KEY:
+    raise RuntimeError("Missing Gemini API key in .env -> GEMINI_API_KEY")
+
+client_provider = AsyncOpenAI(
+    api_key=GEMINI_API_KEY,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+Model = OpenAIChatCompletionsModel(
+    model="gemini-2.0-flash",
+    openai_client=client_provider,
+)
+
+runner = Runner()
+
+# ---------------- Schemas ----------------
+class PredictionInput(BaseModel):
+    location: str
+    crop: str
+    city: Optional[str] = None  # For weather if different from location
+
+class PredictionOutput(BaseModel):
+    location: str
+    crop: str
+    timestamp: str
+    
+    # Weather insights
+    weather_summary: Dict[str, Any]
+    weather_risks: List[str]
+    weather_opportunities: List[str]
+    
+    # Soil insights
+    soil_summary: Dict[str, Any]
+    soil_risks: List[str]
+    soil_opportunities: List[str]
+    
+    # Integrated predictions
+    overall_prediction: str
+    risk_level: str  # low, moderate, high, critical
+    success_probability: float
+    yield_forecast: str
+    
+    # Actionable recommendations
+    immediate_actions: List[str]
+    short_term_actions: List[str]  # 1-2 weeks
+    long_term_actions: List[str]  # 1+ months
+    
+    # Resource optimization
+    irrigation_schedule: Dict[str, Any]
+    fertilizer_schedule: Dict[str, Any]
+    pest_disease_risk: str
+    
+    # Economic insights
+    optimal_harvest_window: str
+    market_timing_advice: str
+    
+    # Summary
+    executive_summary: str
+
+# ---------------- Prediction Workflow Agent ----------------
+# ← CHANGED: Wrapped output_type with AgentOutputSchema
+prediction_agent = Agent(
+    name="AgriPredictionWorkflowAgent",
+    model=Model,
+    instructions="""
+You are the AgriTech Prediction Workflow Agent for the Farmer-Centric Multi-Agent AgriTech System (AgriLedger+).
+
+Your role is to synthesize inputs from Weather and Soil agents to provide comprehensive, actionable farm predictions.
+
+Input: JSON containing:
+- weather_data: complete weather analysis with trends, precipitation, recommendations
+- soil_data: complete soil analysis with health score, nutrients, recommendations
+- crop: target crop
+- location: farm location
+
+Your task:
+1. Analyze weather-soil interactions and their combined impact on the crop
+2. Identify risks (e.g., heavy rain + low drainage soil = waterlogging risk)
+3. Identify opportunities (e.g., warming trend + high nitrogen = optimal growth)
+4. Provide risk level assessment: low/moderate/high/critical
+5. Estimate success probability (0-100%)
+6. Generate time-based action plans (immediate/short-term/long-term)
+7. Optimize resource usage (irrigation, fertilizer) based on both inputs
+8. Predict pest/disease risks based on weather and soil conditions
+9. Suggest optimal harvest timing
+10. Provide executive summary for decision-making
+
+Output: Strict JSON matching the PredictionOutput schema
+
+Constraints:
+- Cross-reference weather and soil data for conflicts/synergies
+- Prioritize immediate risks (next 48 hours)
+- Provide specific, measurable recommendations
+- Include confidence levels where applicable
+- No generic advice - tailor everything to the specific crop, weather, and soil conditions
+- Return strict JSON only
+
+Example risk identification:
+- High precipitation + low soil drainage = "waterlogging risk: immediate drainage required"
+- Warming trend + nitrogen deficiency = "growth limitation: apply nitrogen fertilizer within 3 days"
+- Low moisture + high temperature = "drought stress: increase irrigation by 30%"
+
+Example opportunities:
+- Optimal temperature + balanced nutrients = "peak growth phase: maintain current practices"
+- Moderate rainfall + good soil health = "ideal conditions: consider early harvest"
+""",
+    output_type=AgentOutputSchema(PredictionOutput, strict_json_schema=False),  # ← FIX HERE
+)
+
+# ---------------- Helper functions ----------------
+async def collect_agent_data(location: str, crop: str, city: Optional[str] = None):
+    """Collect data from weather and soil agents"""
+    
+    # Use city for weather if provided, otherwise use location
+    weather_city = city or location
+    
+    print(f"🌤️  Fetching weather data for {weather_city}...")
+    weather_data = await run_weather_agent(weather_city)
+    
+    print(f"🌱 Fetching soil data for {location} (crop: {crop})...")
+    soil_data = await run_soil_agent(location, crop)
+    
+    return {
+        "weather": weather_data,
+        "soil": soil_data
+    }
+
+def calculate_risk_level(weather_data: Dict, soil_data: Dict) -> str:
+    """Calculate overall risk level based on weather and soil conditions"""
+    risk_score = 0
+    
+    # Weather risks
+    precip_chance = weather_data.get("precipitation_chance", 0)
+    if precip_chance > 70:
+        risk_score += 3
+    elif precip_chance > 40:
+        risk_score += 2
+    
+    trend = weather_data.get("trend", "stable")
+    if trend in ["warming", "cooling"]:
+        risk_score += 1
+    
+    # Soil risks
+    health_score = soil_data.get("soil_health_score", 100)
+    if health_score < 50:
+        risk_score += 3
+    elif health_score < 70:
+        risk_score += 2
+    elif health_score < 85:
+        risk_score += 1
+    
+    warnings = len(soil_data.get("warnings", []))
+    risk_score += warnings
+    
+    # Classify risk
+    if risk_score >= 6:
+        return "critical"
+    elif risk_score >= 4:
+        return "high"
+    elif risk_score >= 2:
+        return "moderate"
+    else:
+        return "low"
+
+def estimate_success_probability(risk_level: str, weather_data: Dict, soil_data: Dict) -> float:
+    """Estimate crop success probability based on conditions"""
+    base_probability = {
+        "low": 85.0,
+        "moderate": 70.0,
+        "high": 55.0,
+        "critical": 35.0
+    }.get(risk_level, 70.0)
+    
+    # Adjust based on soil health
+    soil_health = soil_data.get("soil_health_score", 70)
+    soil_factor = (soil_health - 70) * 0.3
+    
+    # Adjust based on weather favorability
+    precip_chance = weather_data.get("precipitation_chance", 0)
+    if 20 <= precip_chance <= 40:
+        weather_factor = 5.0  # Ideal precipitation
+    elif precip_chance < 10:
+        weather_factor = -10.0  # Too dry
+    elif precip_chance > 70:
+        weather_factor = -10.0  # Too wet
+    else:
+        weather_factor = 0.0
+    
+    final_probability = base_probability + soil_factor + weather_factor
+    return round(max(10.0, min(95.0, final_probability)), 2)
+
+def generate_irrigation_schedule(weather_data: Dict, soil_data: Dict) -> Dict[str, Any]:
+    """Generate irrigation schedule based on weather and soil"""
+    
+    moisture = soil_data.get("soil_data", {}).get("moisture_percent", 20)
+    precip_chance = weather_data.get("precipitation_chance", 0)
+    trend = weather_data.get("trend", "stable")
+    
+    # Base frequency
+    if moisture < 15:
+        frequency = "daily"
+        amount = "heavy"
+    elif moisture < 20:
+        frequency = "every 2 days"
+        amount = "moderate"
+    else:
+        frequency = "every 3 days"
+        amount = "light"
+    
+    # Adjust for precipitation
+    if precip_chance > 50:
+        frequency = "pause for 3 days"
+        amount = "none"
+    elif precip_chance > 30:
+        frequency = f"{frequency} (reduce if rain occurs)"
+        amount = "light"
+    
+    # Adjust for temperature trend
+    if trend == "warming":
+        amount = "increase by 20%"
+    elif trend == "cooling":
+        amount = "reduce by 10%"
+    
+    return {
+        "frequency": frequency,
+        "amount": amount,
+        "method": "drip irrigation recommended",
+        "timing": "early morning (6-8 AM)",
+        "notes": f"Current moisture: {moisture}%, precipitation chance: {precip_chance}%"
+    }
+
+def predict_pest_disease_risk(weather_data: Dict, soil_data: Dict, crop: str) -> str:
+    """Predict pest and disease risk based on conditions"""
+    
+    precip_chance = weather_data.get("precipitation_chance", 0)
+    moisture = soil_data.get("soil_data", {}).get("moisture_percent", 20)
+    health_score = soil_data.get("soil_health_score", 70)
+    
+    risk_score = 0
+    
+    # High humidity increases fungal disease risk
+    if precip_chance > 60 and moisture > 25:
+        risk_score += 3
+    elif precip_chance > 40 or moisture > 25:
+        risk_score += 2
+    
+    # Poor soil health = more susceptible
+    if health_score < 60:
+        risk_score += 2
+    elif health_score < 75:
+        risk_score += 1
+    
+    # Crop-specific risks
+    high_risk_crops = ["tomato", "potato", "rice"]
+    if crop.lower() in high_risk_crops:
+        risk_score += 1
+    
+    if risk_score >= 5:
+        return "high - immediate preventive measures required"
+    elif risk_score >= 3:
+        return "moderate - monitor closely, prepare treatments"
+    else:
+        return "low - maintain regular monitoring"
+
+def suggest_harvest_window(weather_data: Dict, soil_data: Dict, crop: str) -> str:
+    """Suggest optimal harvest window"""
+    
+    precip_chance = weather_data.get("precipitation_chance", 0)
+    trend = weather_data.get("trend", "stable")
+    
+    # Base harvest timing by crop
+    crop_maturity = {
+        "wheat": "90-120 days",
+        "rice": "120-150 days",
+        "maize": "70-90 days",
+        "cotton": "150-180 days",
+        "potato": "70-90 days",
+        "tomato": "60-85 days"
+    }
+    
+    base_window = crop_maturity.get(crop.lower(), "monitor crop maturity")
+    
+    # Adjust for weather
+    if precip_chance > 60:
+        advice = f"{base_window} - consider early harvest before heavy rains"
+    elif trend == "warming":
+        advice = f"{base_window} - warming trend may accelerate maturity"
+    elif trend == "cooling":
+        advice = f"{base_window} - cooling may delay maturity slightly"
+    else:
+        advice = f"{base_window} - conditions favorable for normal schedule"
+    
+    return advice
+
+# ---------------- Main Workflow ----------------
+async def run_prediction_workflow(location: str, crop: str, city: Optional[str] = None):
+    """
+    Run the complete prediction workflow:
+    1. Collect weather and soil data
+    2. Analyze combined insights
+    3. Generate comprehensive predictions
+    """
+    
+    print("\n" + "="*70)
+    print("🚜 AGRI PREDICTION WORKFLOW")
+    print("="*70)
+    print(f"📍 Location: {location}")
+    print(f"🌾 Crop: {crop}")
+    print(f"🌤️  Weather City: {city or location}")
+    print(f"⏰ Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("="*70 + "\n")
+    
+    # Step 1: Collect data from specialized agents
+    try:
+        agent_data = await collect_agent_data(location, crop, city)
+        weather_data = agent_data["weather"]
+        soil_data = agent_data["soil"]
+    except Exception as e:
+        print(f"❌ Data collection failed: {e}")
+        return {"error": f"Failed to collect agent data: {str(e)}"}
+    
+    # Check for errors in individual agents
+    if "error" in weather_data:
+        return {"error": f"Weather agent error: {weather_data['error']}"}
+    if "error" in soil_data:
+        return {"error": f"Soil agent error: {soil_data['error']}"}
+    
+    # Step 2: Calculate derived metrics
+    risk_level = calculate_risk_level(weather_data, soil_data)
+    success_probability = estimate_success_probability(risk_level, weather_data, soil_data)
+    irrigation_schedule = generate_irrigation_schedule(weather_data, soil_data)
+    pest_risk = predict_pest_disease_risk(weather_data, soil_data, crop)
+    harvest_window = suggest_harvest_window(weather_data, soil_data, crop)
+    
+    # Step 3: Prepare message for prediction agent
+    message = json.dumps({
+        "location": location,
+        "crop": crop,
+        "weather_data": weather_data,
+        "soil_data": soil_data,
+        "calculated_risk_level": risk_level,
+        "calculated_success_probability": success_probability,
+        "irrigation_schedule": irrigation_schedule,
+        "pest_risk": pest_risk,
+        "harvest_window": harvest_window,
+        "timestamp": datetime.now().isoformat()
+    }, ensure_ascii=False)
+    
+    # Step 4: Run prediction agent
+    print("🤖 Running prediction synthesis agent...\n")
+    try:
+        resp = await runner.run(
+            prediction_agent,
+            message,
+            session=SQLiteSession("trace.db")
+        )
+        if hasattr(resp, "output"):
+            prediction_output = resp.output.model_dump()
+        elif hasattr(resp, "final_output"):
+            prediction_output = resp.final_output.model_dump()
+        else:
+            prediction_output = {}
+    except Exception as e:
+        print(f"❌ Prediction agent failed: {e}")
+        prediction_output = {}
+    
+    # Step 5: Fallback logic if agent fails
+    if not prediction_output:
+        print("⚠️  Agent failed, generating fallback prediction...\n")
+        
+        # Extract key insights
+        weather_summary = {
+            "trend": weather_data.get("trend", "unknown"),
+            "precipitation_chance": weather_data.get("precipitation_chance", 0),
+            "recommendations": weather_data.get("recommendations", [])
+        }
+        
+        soil_summary = {
+            "health_score": soil_data.get("soil_health_score", 0),
+            "nutrient_status": soil_data.get("nutrient_status", {}),
+            "deficiencies": soil_data.get("deficiencies", [])
+        }
+        
+        # Identify risks
+        weather_risks = []
+        if weather_data.get("precipitation_chance", 0) > 60:
+            weather_risks.append("high precipitation risk - waterlogging possible")
+        if weather_data.get("trend") == "warming":
+            weather_risks.append("warming trend - increased water demand")
+        
+        soil_risks = soil_data.get("warnings", [])
+        
+        # Identify opportunities
+        weather_opportunities = []
+        soil_opportunities = []
+        
+        if 20 <= weather_data.get("precipitation_chance", 0) <= 40:
+            weather_opportunities.append("ideal rainfall conditions")
+        if soil_data.get("soil_health_score", 0) > 75:
+            soil_opportunities.append("good soil health - optimal for growth")
+        
+        # Generate recommendations
+        immediate_actions = []
+        immediate_actions.extend(weather_data.get("recommendations", [])[:2])
+        immediate_actions.extend(soil_data.get("recommendations", [])[:2])
+        
+        # Remove duplicates
+        immediate_actions = list(dict.fromkeys(immediate_actions))
+        
+        short_term_actions = [
+            "monitor weather changes daily",
+            "track soil moisture levels",
+            "inspect crop for pest/disease signs"
+        ]
+        
+        long_term_actions = [
+            "improve soil organic matter content",
+            "implement precision farming techniques",
+            "plan crop rotation for next season"
+        ]
+        
+        # Generate yield forecast
+        if success_probability > 75:
+            yield_forecast = "good to excellent yield expected"
+        elif success_probability > 60:
+            yield_forecast = "moderate to good yield expected"
+        elif success_probability > 45:
+            yield_forecast = "fair yield expected with proper management"
+        else:
+            yield_forecast = "below average yield - intervention required"
+        
+        prediction_output = {
+            "location": location,
+            "crop": crop,
+            "timestamp": datetime.now().isoformat(),
+            
+            "weather_summary": weather_summary,
+            "weather_risks": weather_risks or ["minimal weather risks"],
+            "weather_opportunities": weather_opportunities or ["stable conditions"],
+            
+            "soil_summary": soil_summary,
+            "soil_risks": soil_risks or ["no critical soil issues"],
+            "soil_opportunities": soil_opportunities or ["maintain current practices"],
+            
+            "overall_prediction": f"{crop} cultivation at {location} - {risk_level} risk level",
+            "risk_level": risk_level,
+            "success_probability": success_probability,
+            "yield_forecast": yield_forecast,
+            
+            "immediate_actions": immediate_actions,
+            "short_term_actions": short_term_actions,
+            "long_term_actions": long_term_actions,
+            
+            "irrigation_schedule": irrigation_schedule,
+            "fertilizer_schedule": soil_data.get("fertilizer_plan", {}),
+            "pest_disease_risk": pest_risk,
+            
+            "optimal_harvest_window": harvest_window,
+            "market_timing_advice": "consult market agent for current price trends",
+            
+            "executive_summary": (
+                f"Risk Level: {risk_level.upper()}. "
+                f"Success Probability: {success_probability}%. "
+                f"Weather: {weather_data.get('trend', 'stable')} trend, "
+                f"{weather_data.get('precipitation_chance', 0)}% rain chance. "
+                f"Soil Health: {soil_data.get('soil_health_score', 0)}/100. "
+                f"Key actions: {', '.join(immediate_actions[:3])}."
+            )
+        }
+    
+    # Step 6: Display results
+    print("="*70)
+    print("📊 PREDICTION RESULTS")
+    print("="*70)
+    print(f"⚠️  Risk Level: {prediction_output['risk_level'].upper()}")
+    print(f"📈 Success Probability: {prediction_output['success_probability']}%")
+    print(f"🎯 Yield Forecast: {prediction_output.get('yield_forecast', 'N/A')}")
+    print(f"🐛 Pest/Disease Risk: {prediction_output.get('pest_disease_risk', 'N/A')}")
+    print("\n🔴 IMMEDIATE ACTIONS (Next 48 hours):")
+    for action in prediction_output.get('immediate_actions', [])[:5]:
+        print(f"  • {action}")
+    print("\n📋 Executive Summary:")
+    print(f"  {prediction_output.get('executive_summary', 'N/A')}")
+    print("="*70 + "\n")
+    
+    return prediction_output
+
+# ---------------- Run standalone ----------------
+if __name__ == "__main__":
+    print("🌾 AgriLedger+ Prediction Workflow Agent")
+    print("=" * 70)
+    
+    location_input = input("Enter farm location: ")
+    crop_input = input("Enter crop name: ")
+    city_input = input("Enter city for weather (press Enter to use location): ").strip() or None
+    
+    result = asyncio.run(run_prediction_workflow(location_input, crop_input, city_input))
+    
+    print("\n📄 Full JSON Output:")
+    print(json.dumps(result, indent=2, ensure_ascii=False))

ageents/soilAgent.py

@@ -0,0 +1,334 @@
+import os
+import json
+import asyncio
+from dotenv import load_dotenv, find_dotenv
+from pydantic import BaseModel
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+from agents import (
+    Agent,
+    Runner,
+    AsyncOpenAI,
+    OpenAIChatCompletionsModel,
+    set_tracing_disabled,
+    SQLiteSession,
+)
+from firebase_config import get_db_ref
+
+# ---------------- Setup ----------------
+load_dotenv(find_dotenv())
+set_tracing_disabled(True)
+
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if not GEMINI_API_KEY:
+    raise RuntimeError("Missing Gemini API key in .env -> GEMINI_API_KEY")
+
+client_provider = AsyncOpenAI(
+    api_key=GEMINI_API_KEY,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+Model = OpenAIChatCompletionsModel(
+    model="gemini-2.0-flash",
+    openai_client=client_provider,
+)
+
+runner = Runner()
+
+# ---------------- Schemas ----------------
+class SoilInput(BaseModel):
+    location: str
+    crop: Optional[str] = None
+
+class SoilOutput(BaseModel):
+    location: str
+    crop: Optional[str]
+    soil_data: Dict[str, Any]
+    soil_health_score: float
+    nutrient_status: Dict[str, str]
+    recommendations: List[str]
+    fertilizer_plan: Dict[str, Any]
+    irrigation_advice: str
+    soil_type_suitability: str
+    deficiencies: List[str]
+    warnings: List[str]
+    summary: str
+
+# ---------------- Helper functions ----------------
+def fetch_soil_data(location: str, crop: Optional[str] = None) -> Dict[str, Any]:
+    """Fetch soil data from Firebase for a specific location and optionally crop"""
+    try:
+        ref = get_db_ref("soil_data/latest")
+        all_data = ref.get() or {}
+        
+        # Find matching soil data for location
+        matching_samples = []
+        for location_key, samples in all_data.items():
+            if isinstance(samples, dict):
+                for sample_id, sample in samples.items():
+                    if isinstance(sample, dict):
+                        sample_location = sample.get("location", "").lower()
+                        sample_crop = sample.get("crop", "").lower()
+                        
+                        # Match by location
+                        if location.lower() in sample_location or sample_location in location.lower():
+                            # If crop specified, filter by crop too
+                            if crop:
+                                if crop.lower() in sample_crop or sample_crop in crop.lower():
+                                    matching_samples.append(sample)
+                            else:
+                                matching_samples.append(sample)
+        
+        if not matching_samples:
+            # If no exact match, get latest sample for any location
+            latest_ref = get_db_ref("soil_data/latest")
+            latest = latest_ref.get()
+            if latest and "sample" in latest:
+                return latest["sample"]
+            raise ValueError(f"No soil data found for location: {location}")
+        
+        # Return the most recent sample
+        matching_samples.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+        return matching_samples[0]
+        
+    except Exception as e:
+        raise RuntimeError(f"Failed to fetch soil data: {str(e)}")
+
+def calculate_soil_health_score(soil_data: Dict[str, Any]) -> float:
+    """Calculate overall soil health score (0-100)"""
+    scores = []
+    
+    # pH score (optimal range: 6.0-7.5)
+    ph = soil_data.get("ph", 7.0)
+    if 6.0 <= ph <= 7.5:
+        ph_score = 100
+    elif 5.5 <= ph < 6.0 or 7.5 < ph <= 8.0:
+        ph_score = 70
+    else:
+        ph_score = 40
+    scores.append(ph_score)
+    
+    # Nutrient scores (N, P, K levels)
+    nutrient_levels = {
+        "nitrogen": soil_data.get("nitrogen_ppm", 0),
+        "phosphorus": soil_data.get("phosphorus_ppm", 0),
+        "potassium": soil_data.get("potassium_ppm", 0)
+    }
+    
+    # Optimal ranges (ppm)
+    optimal_ranges = {
+        "nitrogen": (40, 80),
+        "phosphorus": (25, 50),
+        "potassium": (150, 300)
+    }
+    
+    for nutrient, value in nutrient_levels.items():
+        min_val, max_val = optimal_ranges[nutrient]
+        if min_val <= value <= max_val:
+            scores.append(100)
+        elif value < min_val:
+            scores.append(max(40, (value / min_val) * 100))
+        else:
+            scores.append(max(60, 100 - ((value - max_val) / max_val) * 40))
+    
+    # Organic matter score (optimal: >2%)
+    om = soil_data.get("organic_matter_percent", 2.0)
+    if om >= 2.5:
+        scores.append(100)
+    elif om >= 1.5:
+        scores.append(75)
+    else:
+        scores.append(50)
+    
+    # Moisture score
+    moisture = soil_data.get("moisture_percent", 20)
+    if 15 <= moisture <= 25:
+        scores.append(100)
+    elif 10 <= moisture < 15 or 25 < moisture <= 35:
+        scores.append(70)
+    else:
+        scores.append(50)
+    
+    return round(sum(scores) / len(scores), 2)
+
+def analyze_nutrient_status(soil_data: Dict[str, Any]) -> Dict[str, str]:
+    """Analyze nutrient levels and return status"""
+    status = {}
+    
+    nitrogen = soil_data.get("nitrogen_ppm", 0)
+    status["nitrogen"] = "optimal" if 40 <= nitrogen <= 80 else ("low" if nitrogen < 40 else "high")
+    
+    phosphorus = soil_data.get("phosphorus_ppm", 0)
+    status["phosphorus"] = "optimal" if 25 <= phosphorus <= 50 else ("low" if phosphorus < 25 else "high")
+    
+    potassium = soil_data.get("potassium_ppm", 0)
+    status["potassium"] = "optimal" if 150 <= potassium <= 300 else ("low" if potassium < 150 else "high")
+    
+    om = soil_data.get("organic_matter_percent", 0)
+    status["organic_matter"] = "optimal" if om >= 2.5 else ("moderate" if om >= 1.5 else "low")
+    
+    return status
+
+def generate_fertilizer_plan(soil_data: Dict[str, Any], nutrient_status: Dict[str, str]) -> Dict[str, Any]:
+    """Generate fertilizer recommendations based on soil analysis"""
+    plan = {
+        "npk_ratio": "0-0-0",
+        "dosage_per_acre": "0 kg",
+        "application_method": "broadcast",
+        "timing": "pre-planting",
+        "organic_alternatives": []
+    }
+    
+    n_status = nutrient_status.get("nitrogen", "optimal")
+    p_status = nutrient_status.get("phosphorus", "optimal")
+    k_status = nutrient_status.get("potassium", "optimal")
+    
+    # Determine NPK ratio
+    n = 10 if n_status == "low" else (5 if n_status == "optimal" else 0)
+    p = 10 if p_status == "low" else (5 if p_status == "optimal" else 0)
+    k = 10 if k_status == "low" else (5 if k_status == "optimal" else 0)
+    
+    plan["npk_ratio"] = f"{n}-{p}-{k}"
+    
+    # Calculate dosage
+    total_units = n + p + k
+    plan["dosage_per_acre"] = f"{total_units * 10} kg" if total_units > 0 else "0 kg"
+    
+    # Organic alternatives
+    if n_status == "low":
+        plan["organic_alternatives"].append("compost (2-3 tons/acre)")
+    if p_status == "low":
+        plan["organic_alternatives"].append("bone meal (50 kg/acre)")
+    if k_status == "low":
+        plan["organic_alternatives"].append("wood ash (30 kg/acre)")
+    
+    return plan
+
+# ---------------- Agent ----------------
+soil_agent = Agent(
+    name="AgriSoilAgent",
+    model=Model,
+    instructions="""
+You are an AgriTech Soil Analysis Agent for the Farmer-Centric Multi-Agent AgriTech System (AgriLedger+).
+Your job is to analyze soil data and provide structured, actionable recommendations for farm operations.
+
+Input: JSON containing soil sample data with:
+- pH, nitrogen_ppm, phosphorus_ppm, potassium_ppm
+- organic_matter_percent, moisture_percent
+- soil_type, location, crop
+
+Output: Strict JSON (no human-readable text) containing:
+- location: string
+- crop: optional string
+- soil_data: raw soil measurements
+- soil_health_score: 0-100 score
+- nutrient_status: dict with status for each nutrient (low/optimal/high)
+- recommendations: list of machine-readable instructions for automated operations
+- fertilizer_plan: structured fertilizer recommendations
+- irrigation_advice: water management guidance
+- soil_type_suitability: assessment for specified crop
+- deficiencies: list of critical deficiencies
+- warnings: list of urgent actions needed
+- summary: brief technical summary
+
+Recommendations format examples:
+- "fertilizer: apply NPK 10-10-10 @ 150kg/acre"
+- "irrigation: increase frequency by 20%"
+- "amendment: add lime @ 500kg/acre to raise pH"
+- "organic_matter: add compost @ 2 tons/acre"
+
+Constraints:
+- Return strict JSON matching the schema
+- Focus on actionable, measurable recommendations
+- Include all fields even if empty/null
+- No human-readable explanations outside JSON structure
+""",
+    output_type=SoilOutput,
+)
+
+# ---------------- Main Flow ----------------
+async def run_soil_agent(location: str, crop: Optional[str] = None):
+    """Run soil analysis agent for a given location and optional crop"""
+    try:
+        soil_data = fetch_soil_data(location, crop)
+    except Exception as e:
+        print(f"❌ Soil data fetch error: {e}")
+        return {"error": str(e)}
+
+    # Calculate derived metrics
+    health_score = calculate_soil_health_score(soil_data)
+    nutrient_status = analyze_nutrient_status(soil_data)
+    fertilizer_plan = generate_fertilizer_plan(soil_data, nutrient_status)
+
+    # Prepare message for agent
+    message = json.dumps({
+        "soil_data": soil_data,
+        "calculated_health_score": health_score,
+        "nutrient_status": nutrient_status,
+        "fertilizer_plan": fertilizer_plan
+    }, ensure_ascii=False)
+
+    try:
+        resp = await runner.run(
+            soil_agent,
+            message,
+            session=SQLiteSession("trace.db")
+        )
+        if hasattr(resp, "output"):
+            agent_output = resp.output.model_dump()
+        elif hasattr(resp, "final_output"):
+            agent_output = resp.final_output.model_dump()
+        else:
+            agent_output = {}
+    except Exception as e:
+        print(f"❌ Agent run failed: {e}")
+        agent_output = {}
+
+    # Fallback if agent fails
+    if not agent_output:
+        deficiencies = []
+        warnings = []
+        recommendations = []
+
+        for nutrient, status in nutrient_status.items():
+            if status == "low":
+                deficiencies.append(f"{nutrient} deficiency detected")
+                recommendations.append(f"fertilizer: apply {nutrient} supplement")
+        
+        ph = soil_data.get("ph", 7.0)
+        if ph < 6.0:
+            warnings.append("acidic soil detected")
+            recommendations.append("amendment: add lime to raise pH")
+        elif ph > 8.0:
+            warnings.append("alkaline soil detected")
+            recommendations.append("amendment: add sulfur to lower pH")
+
+        moisture = soil_data.get("moisture_percent", 20)
+        if moisture < 15:
+            warnings.append("low soil moisture")
+            recommendations.append("irrigation: increase immediately")
+
+        agent_output = {
+            "location": soil_data.get("location", location),
+            "crop": crop or soil_data.get("crop"),
+            "soil_data": soil_data,
+            "soil_health_score": health_score,
+            "nutrient_status": nutrient_status,
+            "recommendations": recommendations or ["monitor: normal"],
+            "fertilizer_plan": fertilizer_plan,
+            "irrigation_advice": "moderate watering" if 15 <= moisture <= 25 else ("increase watering" if moisture < 15 else "reduce watering"),
+            "soil_type_suitability": "suitable for most crops",
+            "deficiencies": deficiencies,
+            "warnings": warnings,
+            "summary": f"Soil health: {health_score}/100. " + (", ".join(warnings) if warnings else "No critical issues.")
+        }
+
+    print(json.dumps(agent_output, indent=2, ensure_ascii=False))
+    return agent_output
+
+# ---------------- Run standalone ----------------
+if __name__ == "__main__":
+    location_name = input("Enter location name: ")
+    crop_name = input("Enter crop name (optional, press Enter to skip): ").strip() or None
+    asyncio.run(run_soil_agent(location_name, crop_name))

ageents/weatherAgent.py

@@ -0,0 +1,237 @@
+import os
+import json
+import asyncio
+from dotenv import load_dotenv, find_dotenv
+from pydantic import BaseModel
+from typing import Dict, Any, List, Optional
+import requests
+
+from agents import (
+    Agent,
+    Runner,
+    AsyncOpenAI,
+    OpenAIChatCompletionsModel,
+    set_tracing_disabled,
+    SQLiteSession,
+)
+
+# ---------------- Setup ----------------
+load_dotenv(find_dotenv())
+set_tracing_disabled(True)
+
+WEATHER_API_KEY = os.getenv("API_KEY")
+GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
+
+if not WEATHER_API_KEY:
+    raise RuntimeError("Missing OpenWeatherMap API key in .env -> API_KEY")
+if not GEMINI_API_KEY:
+    raise RuntimeError("Missing Gemini API key in .env -> GEMINI_API_KEY")
+
+client_provider = AsyncOpenAI(
+    api_key=GEMINI_API_KEY,
+    base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+)
+Model = OpenAIChatCompletionsModel(
+    model="gemini-2.0-flash",
+    openai_client=client_provider,
+)
+
+runner = Runner()
+
+# ---------------- Schemas ----------------
+class WeatherInput(BaseModel):
+    city: str
+
+class WeatherOutput(BaseModel):
+    city: str
+    current: Dict[str, Any]
+    raw_forecast: List[Dict[str, Any]]
+    daily_summary: Dict[str, Dict[str, Any]]
+    recommendations: Optional[List[str]] = []
+    trend: Optional[str] = None
+    precipitation_chance: Optional[float] = None
+    summary: Optional[str] = None
+
+# ---------------- Helper functions ----------------
+def fetch_current(city: str) -> Dict[str, Any]:
+    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={WEATHER_API_KEY}&units=metric"
+    r = requests.get(url, timeout=10)
+    r.raise_for_status()
+    return r.json()
+
+def fetch_forecast(city: str) -> Dict[str, Any]:
+    url = f"http://api.openweathermap.org/data/2.5/forecast?q={city}&appid={WEATHER_API_KEY}&units=metric"
+    r = requests.get(url, timeout=10)
+    r.raise_for_status()
+    return r.json()
+
+def aggregate_daily_forecast(forecast_data: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
+    from collections import defaultdict, Counter
+    daily_data = defaultdict(list)
+    for entry in forecast_data.get("list", []):
+        date = entry["dt_txt"].split(" ")[0]
+        daily_data[date].append(entry)
+
+    structured_forecast = {}
+    for date, entries in daily_data.items():
+        temps = [e['main']['temp'] for e in entries]
+        feels_like = [e['main']['feels_like'] for e in entries]
+        humidity = [e['main']['humidity'] for e in entries]
+        wind_speed = [e['wind']['speed'] for e in entries]
+        descriptions = [e['weather'][0]['description'].title() for e in entries]
+        most_common_desc = Counter(descriptions).most_common(1)[0][0]
+
+        structured_forecast[date] = {
+            "temperature": f"{sum(temps)/len(temps):.2f} °C",
+            "feels_like": f"{sum(feels_like)/len(feels_like):.2f} °C",
+            "description": most_common_desc,
+            "humidity": f"{sum(humidity)/len(humidity):.0f}%",
+            "wind_speed": f"{sum(wind_speed)/len(wind_speed):.2f} m/s"
+        }
+    return structured_forecast
+
+# ---------------- Agent ----------------
+weather_agent = Agent(
+    name="AgriWeatherAgent",
+    model=Model,
+    instructions="""
+    You are an AgriTech Weather Agent for the Farmer-Centric Multi-Agent AgriTech System (AgriLedger+). 
+Your job is to process raw weather data from OpenWeatherMap and generate structured outputs for automated farm operations and multi-agent advisory use.
+
+Input: JSON containing:
+- "current": current weather data
+- "forecast": 5-day / 3-hour interval forecast
+
+Output: Strict JSON (no human-readable text) containing:
+- city: string
+- current: 
+    - temperature: float °C
+    - feels_like: float °C
+    - description: weather description
+    - humidity: % value
+    - wind_speed: m/s
+- raw_forecast: list of 3-hour interval forecast entries as returned by OpenWeatherMap
+- daily_summary: aggregated daily forecast with:
+    - temperature, feels_like, description, humidity, wind_speed
+- trend: one of "warming", "cooling", "stable" based on temperature over next 3 days
+- precipitation_chance: estimated % chance of rain over next 3 days
+- recommendations: structured machine-readable instructions for automated farm operations only, e.g.,
+    - "irrigation: postpone"
+    - "fertilizer: delay"
+    - "pesticide: apply"
+
+Constraints:
+- Do NOT generate any human-readable summaries or explanations.
+- Return strict JSON that matches the schema above.
+- Include all fields even if empty; null is acceptable.
+    """,
+    output_type=WeatherOutput,
+)
+
+# ---------------- Main Flow ----------------
+async def run_weather_agent(city: str):
+    try:
+        current = fetch_current(city)
+        forecast = fetch_forecast(city)
+    except Exception as e:
+        print(f"❌ OpenWeatherMap API error: {e}")
+        return {}
+
+    daily_summary = aggregate_daily_forecast(forecast)
+    message = json.dumps({
+        "current": current,
+        "forecast": forecast
+    }, ensure_ascii=False)
+
+    try:
+        resp = await runner.run(
+            weather_agent,
+            message,
+            session=SQLiteSession("trace.db")
+        )
+        if hasattr(resp, "output"):
+            agent_output = resp.output.model_dump()
+        elif hasattr(resp, "final_output"):
+            agent_output = resp.final_output.model_dump()
+        else:
+            agent_output = {}
+    except Exception as e:
+        print(f"❌ Agent run failed: {e}")
+        agent_output = {}
+
+    # --- Fallback if agent fails ---
+    if not agent_output:
+        agent_output = {
+            "city": current.get("name", city),
+            "current": {
+                "temperature": f"{current.get('main', {}).get('temp')} °C",
+                "feels_like": f"{current.get('main', {}).get('feels_like')} °C",
+                "description": current.get('weather',[{}])[0].get('description','').title(),
+                "humidity": f"{current.get('main', {}).get('humidity')}%",
+                "wind_speed": f"{current.get('wind',{}).get('speed')} m/s"
+            },
+            "raw_forecast": forecast.get("list", []),
+            "daily_summary": daily_summary,
+            "recommendations": []
+        }
+
+    # --- Add computed trend, precipitation chance & summary ---
+    try:
+        temps = []
+        for d in list(daily_summary.values())[:3]:
+            t = d["temperature"].split(" ")[0]
+            try:
+                temps.append(float(t))
+            except:
+                pass
+
+        # Compute trend
+        if len(temps) >= 2:
+            diff = temps[-1] - temps[0]
+            if diff > 1:
+                trend = "warming"
+            elif diff < -1:
+                trend = "cooling"
+            else:
+                trend = "stable"
+        else:
+            trend = "stable"
+
+        # Estimate precipitation chance
+        forecast_list = forecast.get("list", [])
+        rainy = [f for f in forecast_list if "rain" in f.get("weather", [{}])[0].get("description", "").lower()]
+        precipitation_chance = round(len(rainy) / len(forecast_list) * 100, 2) if forecast_list else 0
+
+        # Add default recommendations
+        recommendations = agent_output.get("recommendations", [])
+        if not recommendations:
+            if trend == "warming":
+                recommendations = ["irrigation: increase"]
+            elif trend == "cooling":
+                recommendations = ["irrigation: reduce"]
+            elif precipitation_chance > 40:
+                recommendations = ["fertilizer: delay", "irrigation: postpone"]
+            else:
+                recommendations = ["monitor: normal"]
+
+        agent_output["trend"] = trend
+        agent_output["precipitation_chance"] = precipitation_chance
+        agent_output["recommendations"] = recommendations
+        agent_output["summary"] = (
+            f"Trend: {trend.capitalize()}, "
+            f"Rain chance: {precipitation_chance}%. "
+            f"Recommended actions: {', '.join(recommendations)}."
+        )
+
+    except Exception as e:
+        agent_output["trend"] = "unknown"
+        agent_output["precipitation_chance"] = None
+        agent_output["summary"] = f"Summary unavailable due to error: {str(e)}"
+
+    print(json.dumps(agent_output, indent=2, ensure_ascii=False))
+    return agent_output
+
+# ---------------- Run standalone ----------------
+if __name__ == "__main__":
+    city_name = input("Enter city name: ")
+    asyncio.run(run_weather_agent(city_name))

firebase_config.py

@@ -0,0 +1,18 @@
+import firebase_admin
+from firebase_admin import credentials, db
+import os
+
+SERVICE_ACCOUNT_KEY = os.path.join(os.path.dirname(__file__), "firebase_key.json")
+
+if not firebase_admin._apps:
+    cred = credentials.Certificate(SERVICE_ACCOUNT_KEY)
+    firebase_admin.initialize_app(cred, {
+        "databaseURL": "https://fintech-backend-1f7c0-default-rtdb.firebaseio.com" 
+    })
+
+def get_db_ref(path: str = "/"):
+    """
+    Get a reference to a specific path in Firebase Realtime Database.
+    Example: get_db_ref("entries") → /entries
+    """
+    return db.reference(path)

firebase_key.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "fintech-backend-1f7c0",
+  "private_key_id": "d63430dac92893561935331d751dd0304a8b3d07",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCMS+uta8AqhkRG\nA81wycLVc9nlQRRw5LyhYODpTI6b7WRl8O2Be4xbjhyM1Um2kD6hLrCT1dbgJJKg\nSPxYuzc9BGWzpITmIfFX2V/SfcN3Xlm3BgzWdOVefjZuEe+QXqBMhwoebjPasRki\nfNdqObjXIW4o298kH5wcGXx3rLwRJjjFJKaVZw8CWHDGlsDI81WRI2X4f7Qvbk01\nGq5HFF8E7CXpLT5IhcowIMeEZPURFi8tyF2Cutv/xG6p5T3lJSfKQE1PltG3kpHx\n6+3Kjrm8ig7sgyNYG8HTJQos4/6iAhzSJFbcFuXjKR/J7zvdxsjyiducgn0I4b1r\nn9V6+cCjAgMBAAECggEAHwu74vv5oc9lc1LrFt7m+QIygStWISdU4KdGDgptcm7l\nbTOT8zfKVwZLJhUaw0YHPfbNh2FmM+KT+dk80kvXjO6YrNimuiBfvk9xh2xiIVul\nIb26gIiMq0zlsZTRfRKbiWPGpvY/DlFrXPjgWHbegui4bl09c0p1arhvFTKJyYdm\nXyQarg3mzWm01aiKjV3rYdhTKZKlONq81vc+snII9fCw3eddfYkvGhyePmH50niE\nHQOT40YSjWNaliYuK01yygszRo6my1hWQcjV8yx4YXKRzuOxwJmmPk2NqsrZ+32+\nSlJuD7IhoUyvkJ77oq2jmhuoTs0GoNA4Ijo/rmtB4QKBgQC+islrf6GZ8DHZuyGC\n3JlKOcLwU9VIeneomVNLSo8WH5jKqm1ALMWspWo4HtoM/O06XqVa3OysT4K0wJK3\nanun9bWTnAjD0xUhso9+vxopKJCLv1Esbhrkm2SOgOzufwp2XOlutRAzWNiuQV2U\nedUHoJh8/BwcVcyVLjHbmgHBYQKBgQC8fkp/7zMxvXkrz3ptip8IgyaB6ct6W7BC\nsofspKcv9CsaqcMMXT7fdoGh/j9OxV0d6V1MpeT16e2LLWbj50GEkeoDyGdB7BiC\nt+NfD4IGByWYFhIinZSJKMBMW6FCkAtzcS8Suic7viBhDwG5A2HiptqVDH7jk0Ry\nu54vh4tMgwKBgCoqfm5qnTF6xR1g2wahmM6jP699bdqPN4G5BITJ6CZGMcLPukOU\nZN5S8NGgijKLmlfrb/5Om5V6NvuXDiDG0LyXlGopAouLX8bIRBcRZVGsZ2h1mxoQ\n96SVeshKYaRZus/8ua/FI+OpCrJtRq8/0tPQR06JYBMpLY/p3CCz0SWhAoGBAJCN\n+exrMUOwH0Et+KIRcS1CB0ISXm4T6vT7naoqC92Gz5e/IUpWKGWPqJLnPP3X9jV+\nRoMFprXBFN9rjkCxlVlp3aHRCv9PZOy6wbChYAHncTlVk8rgNo2Jpw/oJZ+6gE2k\nO4mNIZF7mbFVpOiSY3tCotczogw9YHzszb99n6KpAoGAXS76tsid/Ga4Cyfa4SZA\n5V9ICEytoc0XWKZoZysb7ws1ryWJNvzodVkbMWXWSbeYDVENfZYFepf77DZofUKj\ntzvqN4eNg/QjZH3W076QGZg7yt1KIYJw0l+2Vv6HZu1xY5b27Hdr3vcmjKLFgSsd\nRMPPg5wx6kTUDUNw0Qxp68U=\n-----END PRIVATE KEY-----\n",
+  "client_email": "firebase-adminsdk-fbsvc@fintech-backend-1f7c0.iam.gserviceaccount.com",
+  "client_id": "115784013323321037308",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-fbsvc%40fintech-backend-1f7c0.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

main.py

@@ -0,0 +1,2264 @@
+"""
+AgriLedger+ FastAPI Backend - Complete Implementation
+Includes entries management and market advisory with seeded data
+"""
+
+import os
+import secrets
+import re
+from datetime import datetime
+from dotenv import load_dotenv
+from fastapi import FastAPI, HTTPException, Query, Body
+from fastapi.middleware.cors import CORSMiddleware
+from typing import Optional, Dict, List
+
+from models.expense import EntryCreate, EntryResponse
+from models.market import (
+    AdviceRequest, 
+    MarketAdviceResponse, 
+    CropSummary,
+    MarketSummaryResponse,
+    HealthStatus,
+    InitializationResponse
+)
+from firebase_config import get_db_ref
+from ageents.marketAgent import get_market_advice
+import bcrypt
+
+load_dotenv()
+
+# -------------------- INIT APP --------------------
+app = FastAPI(
+    title="AgriLedger+ API",
+    description="AI-powered agricultural ledger and market advisory system for Pakistani farmers",
+    version="3.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# -------------------- UTILITIES --------------------
+def generate_short_id(length: int = 7) -> str:
+    """Generate short unique ID"""
+    alphabet = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz"
+    return "".join(secrets.choice(alphabet) for _ in range(length))
+
+
+def parse_advice_to_structured(raw_advice: str, crop: str) -> MarketAdviceResponse:
+    """Parse raw agent advice into structured response"""
+    
+    # Extract action
+    action_match = re.search(r'\*\*Action:\*\*\s*([A-Z\s]+)', raw_advice, re.IGNORECASE)
+    action = action_match.group(1).strip() if action_match else "HOLD"
+    
+    # Extract current price
+    price_match = re.search(r'₨([\d,]+(?:\.\d{2})?)', raw_advice)
+    current_price = float(price_match.group(1).replace(',', '')) if price_match else 0.0
+    
+    # Extract price trend
+    trend_match = re.search(r'Trend:\s*(\w+)\s*by\s*([-+]?\d+\.?\d*)%', raw_advice, re.IGNORECASE)
+    if trend_match:
+        price_trend = f"{trend_match.group(1)} by {trend_match.group(2)}%"
+    else:
+        price_trend = "stable"
+    
+    # Extract confidence
+    confidence_match = re.search(r'\*\*Confidence:\*\*\s*(\w+)', raw_advice, re.IGNORECASE)
+    confidence = confidence_match.group(1).upper() if confidence_match else "MEDIUM"
+    
+    # Extract seasonal context
+    seasonal_match = re.search(r'Seasonal Context:\s*([^\n•]+)', raw_advice, re.IGNORECASE)
+    seasonal_context = seasonal_match.group(1).strip() if seasonal_match else "N/A"
+    
+    # Extract recommendation
+    rec_match = re.search(r'\*\*Recommendation:\*\*\s*([^\n]+)', raw_advice, re.IGNORECASE)
+    reasoning = rec_match.group(1).strip() if rec_match else "Monitor market conditions"
+    
+    # Extract risk factors
+    risk_section = re.search(r'\*\*Risk Factors:\*\*\s*([\s\S]+?)(?:\n\n|\*|\Z)', raw_advice, re.IGNORECASE)
+    risk_factors = []
+    if risk_section:
+        risks = re.findall(r'•\s*([^\n]+)', risk_section.group(1))
+        risk_factors = [r.strip() for r in risks[:3]]
+    
+    if not risk_factors:
+        risk_factors = ["Market volatility", "Seasonal price fluctuations", "Weather conditions"]
+    
+    return MarketAdviceResponse(
+        crop=crop,
+        action=action,
+        current_price=current_price,
+        price_trend=price_trend,
+        confidence=confidence,
+        reasoning=reasoning,
+        risk_factors=risk_factors,
+        seasonal_context=seasonal_context,
+        timestamp=datetime.utcnow().isoformat(),
+        raw_advice=raw_advice
+    )
+
+# ================== AUTH ENDPOINTS ==================
+
+@app.post("/auth/signup", tags=["auth"])
+async def signup(
+    name: str = Body(...),
+    phone: str = Body(...),
+    email: str = Body(...),
+    password: str = Body(...),
+    city: str = Body(...),
+    state: str = Body(...),
+    country: str = Body(...),
+    land_area: float = Body(...),
+    unit: str = Body(...)
+):
+    """User signup - stores user info securely in Firebase"""
+    try:
+        ref = get_db_ref("users")
+
+        # Check if user already exists
+        all_users = ref.get() or {}
+        for _, user in all_users.items():
+            if user.get("email") == email:
+                raise HTTPException(status_code=400, detail="User already exists with this email")
+
+        # Hash password securely
+        hashed_pw = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
+
+        user_id = generate_short_id(8)
+        user_data = {
+            "name": name,
+            "phone": phone,
+            "email": email,
+            "password": hashed_pw,
+            "location": {
+                "city": city,
+                "state": state,
+                "country": country
+            },
+            "land_info": {
+                "area": land_area,
+                "unit": unit
+            },
+            "createdAt": datetime.utcnow().isoformat()
+        }
+
+        ref.child(user_id).set(user_data)
+
+        # Don't return password in response
+        safe_data = {k: v for k, v in user_data.items() if k != "password"}
+
+        return {
+            "message": "Signup successful",
+            "user_id": user_id,
+            "data": safe_data
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error saving user: {str(e)}")
+
+
+@app.post("/auth/login", tags=["auth"])
+async def login(email: str = Body(...), password: str = Body(...)):
+    """User login - verifies email and password (no Firebase index needed)"""
+    try:
+        ref = get_db_ref("users")
+
+        # ✅ Manual lookup instead of using order_by_child (no .indexOn required)
+        all_users = ref.get() or {}
+        found_user = None
+        found_user_id = None
+
+        for uid, user in all_users.items():
+            if user.get("email") == email:
+                found_user = user
+                found_user_id = uid
+                break
+
+        if not found_user:
+            raise HTTPException(status_code=404, detail="User not found")
+
+        stored_pw = found_user.get("password")
+
+        # ✅ Verify password securely
+        if not bcrypt.checkpw(password.encode('utf-8'), stored_pw.encode('utf-8')):
+            raise HTTPException(status_code=400, detail="Incorrect password")
+
+        # ✅ Remove password before sending response
+        safe_data = {k: v for k, v in found_user.items() if k != "password"}
+
+        return {
+            "message": "Login successful",
+            "user_id": found_user_id,
+            "data": safe_data
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Login error: {str(e)}")
+
+
+
+# ================== ENTRIES ENDPOINTS ==================
+
+@app.post("/entries", response_model=EntryResponse, tags=["entries"])
+async def create_entry(payload: EntryCreate):
+    """Create a new ledger entry"""
+    now_iso = datetime.utcnow().isoformat()
+    entry_id = generate_short_id(7)
+
+    entry = {
+        "type": "entry",
+        "entryType": payload.entryType,
+        "category": payload.category,
+        "amount": payload.amount,
+        "currency": payload.currency or "PKR",
+        "paymentMethod": payload.paymentMethod or "cash",
+        "notes": payload.notes,
+        "createdAt": payload.date or now_iso,
+        "recordedBy": payload.recordedBy,
+        "deviceId": payload.deviceId,
+        "syncStatus": "synced",
+        "meta": payload.meta.model_dump() if payload.meta else None,
+    }
+
+    try:
+        ref = get_db_ref("entries")
+        ref.child(entry_id).set(entry)
+        print(f"✅ Entry saved: {entry_id}")
+        return {"id": entry_id, **entry}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Firebase error: {str(e)}")
+
+
+@app.get("/entries", tags=["entries"])
+async def list_entries(
+    limit: Optional[int] = Query(None, ge=1, le=1000),
+    skip: Optional[int] = Query(None, ge=0),
+    entry_type: Optional[str] = Query(None, description="Filter by entryType"),
+    category: Optional[str] = Query(None, description="Filter by category")
+):
+    """List all ledger entries with optional filters"""
+    try:
+        ref = get_db_ref("entries")
+        data = ref.get() or {}
+        entries = [{"id": k, **v} for k, v in data.items()]
+
+        # Apply filters
+        if entry_type:
+            entries = [e for e in entries if e.get("entryType") == entry_type]
+        if category:
+            entries = [e for e in entries if e.get("category") == category]
+
+        # Sort by date (newest first)
+        entries.sort(key=lambda x: x.get("createdAt", ""), reverse=True)
+
+        # Apply pagination
+        if skip:
+            entries = entries[skip:]
+        if limit:
+            entries = entries[:limit]
+
+        return {
+            "total": len(entries),
+            "entries": entries
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Firebase error: {str(e)}")
+
+
+@app.get("/entries/{entry_id}", tags=["entries"])
+async def get_entry(entry_id: str):
+    """Get a specific entry by ID"""
+    try:
+        ref = get_db_ref(f"entries/{entry_id}")
+        entry = ref.get()
+        if not entry:
+            raise HTTPException(status_code=404, detail="Entry not found")
+        return {"id": entry_id, **entry}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Firebase error: {str(e)}")
+
+
+@app.put("/entries/{entry_id}", tags=["entries"])
+async def update_entry(entry_id: str, payload: EntryCreate):
+    """Update an existing entry"""
+    try:
+        ref = get_db_ref(f"entries/{entry_id}")
+        existing = ref.get()
+        if not existing:
+            raise HTTPException(status_code=404, detail="Entry not found")
+
+        updated = {
+            **existing,
+            "entryType": payload.entryType,
+            "category": payload.category,
+            "amount": payload.amount,
+            "currency": payload.currency or "PKR",
+            "paymentMethod": payload.paymentMethod or "cash",
+            "notes": payload.notes,
+            "updatedAt": datetime.utcnow().isoformat(),
+            "meta": payload.meta.model_dump() if payload.meta else existing.get("meta"),
+        }
+
+        ref.set(updated)
+        print(f"✅ Entry updated: {entry_id}")
+        return {"id": entry_id, **updated}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Firebase error: {str(e)}")
+
+
+@app.delete("/entries/{entry_id}", tags=["entries"])
+async def delete_entry(entry_id: str):
+    """Delete an entry"""
+    try:
+        ref = get_db_ref(f"entries/{entry_id}")
+        if not ref.get():
+            raise HTTPException(status_code=404, detail="Entry not found")
+        ref.delete()
+        print(f"🗑️ Entry deleted: {entry_id}")
+        return {"message": "Entry deleted successfully", "id": entry_id}
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Firebase error: {str(e)}")
+
+
+@app.get("/entries/stats/summary", tags=["entries"])
+async def get_entries_summary():
+    """Get summary statistics for entries"""
+    try:
+        ref = get_db_ref("entries")
+        data = ref.get() or {}
+        entries = list(data.values())
+
+        total_income = sum(e["amount"] for e in entries if e.get("entryType") == "income")
+        total_expense = sum(e["amount"] for e in entries if e.get("entryType") == "expense")
+        net_balance = total_income - total_expense
+
+        # Category breakdown
+        categories = {}
+        for entry in entries:
+            cat = entry.get("category", "uncategorized")
+            if cat not in categories:
+                categories[cat] = {"income": 0, "expense": 0, "count": 0}
+            
+            if entry.get("entryType") == "income":
+                categories[cat]["income"] += entry["amount"]
+            else:
+                categories[cat]["expense"] += entry["amount"]
+            categories[cat]["count"] += 1
+
+        return {
+            "total_entries": len(entries),
+            "total_income": round(total_income, 2),
+            "total_expense": round(total_expense, 2),
+            "net_balance": round(net_balance, 2),
+            "categories": categories
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error: {str(e)}")
+
+
+# ================== MARKET ADVISORY ENDPOINTS ==================
+
+@app.get("/advice/{crop}", response_model=MarketAdviceResponse, tags=["market"])
+async def get_crop_advice(
+    crop: str,
+    risk_tolerance: Optional[str] = Query(None, description="low, medium, or high"),
+    budget: Optional[float] = Query(None, description="Available budget in PKR"),
+    land_size: Optional[float] = Query(None, description="Land size in acres"),
+):
+    """Get detailed market advice for a specific crop"""
+    try:
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        if risk_tolerance:
+            farmer_context["risk_tolerance"] = risk_tolerance
+
+        raw_advice = await get_market_advice(crop.lower(), farmer_context or None)
+        structured_response = parse_advice_to_structured(raw_advice, crop)
+        
+        return structured_response
+        
+    except Exception as e:
+        print(f"❌ Market advice error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Market agent error: {str(e)}")
+
+
+@app.post("/advice", response_model=MarketAdviceResponse, tags=["market"])
+async def get_crop_advice_post(request: AdviceRequest):
+    """Get detailed market advice (POST version)"""
+    try:
+        farmer_context = {}
+        if request.budget:
+            farmer_context["budget"] = request.budget
+        if request.land_size:
+            farmer_context["land_size"] = request.land_size
+        if request.risk_tolerance:
+            farmer_context["risk_tolerance"] = request.risk_tolerance
+
+        raw_advice = await get_market_advice(request.crop.lower(), farmer_context or None)
+        structured_response = parse_advice_to_structured(raw_advice, request.crop)
+        
+        return structured_response
+        
+    except Exception as e:
+        print(f"❌ Market advice error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Market agent error: {str(e)}")
+
+
+@app.get("/advice/summary/all", response_model=MarketSummaryResponse, tags=["market"])
+async def get_market_summary(
+    risk_tolerance: Optional[str] = Query(None),
+    budget: Optional[float] = Query(None),
+    land_size: Optional[float] = Query(None),
+):
+    """Get comprehensive market summary for all major crops"""
+    try:
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        if risk_tolerance:
+            farmer_context["risk_tolerance"] = risk_tolerance
+
+        crops = ["wheat", "rice", "maize", "cotton", "sugarcane", "potato", "onion", "tomato"]
+        crop_summaries: List[CropSummary] = []
+        
+        sell_count = 0
+        buy_count = 0
+        hold_count = 0
+
+        for crop in crops:
+            try:
+                raw_advice = await get_market_advice(crop, farmer_context or None)
+                structured = parse_advice_to_structured(raw_advice, crop)
+                
+                summary = CropSummary(
+                    crop=crop,
+                    action=structured.action,
+                    current_price=structured.current_price,
+                    trend=structured.price_trend,
+                    confidence=structured.confidence,
+                    quick_summary=structured.reasoning[:100] + "..." if len(structured.reasoning) > 100 else structured.reasoning
+                )
+                
+                crop_summaries.append(summary)
+                
+                if "SELL" in structured.action.upper():
+                    sell_count += 1
+                elif "BUY" in structured.action.upper():
+                    buy_count += 1
+                else:
+                    hold_count += 1
+                    
+            except Exception as crop_error:
+                print(f"⚠️ Error for {crop}: {str(crop_error)}")
+                crop_summaries.append(CropSummary(
+                    crop=crop,
+                    action="ERROR",
+                    current_price=0.0,
+                    trend="unavailable",
+                    confidence="NONE",
+                    quick_summary=f"Unable to fetch data"
+                ))
+
+        market_overview = f"Market Summary: {sell_count} crops SELL, {buy_count} BUY, {hold_count} HOLD. "
+        
+        if sell_count > buy_count:
+            market_overview += "Market favoring sellers."
+        elif buy_count > sell_count:
+            market_overview += "Good time for input purchasing."
+        else:
+            market_overview += "Mixed market conditions."
+
+        return MarketSummaryResponse(
+            timestamp=datetime.utcnow().isoformat(),
+            farmer_context=farmer_context or None,
+            crops=crop_summaries,
+            market_overview=market_overview
+        )
+        
+    except Exception as e:
+        print(f"❌ Summary error: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Summary error: {str(e)}")
+
+
+@app.get("/advice/{crop}/raw", tags=["market"])
+async def get_crop_advice_raw(
+    crop: str,
+    risk_tolerance: Optional[str] = Query(None),
+    budget: Optional[float] = Query(None),
+    land_size: Optional[float] = Query(None),
+):
+    """Get raw unstructured advice (backward compatibility)"""
+    try:
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        if risk_tolerance:
+            farmer_context["risk_tolerance"] = risk_tolerance
+
+        advice = await get_market_advice(crop.lower(), farmer_context or None)
+        
+        return {
+            "crop": crop,
+            "advice": advice,
+            "timestamp": datetime.utcnow().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ================== MARKET DATA ENDPOINTS ==================
+
+@app.get("/market/prices/current", tags=["market-data"])
+async def get_current_prices(crop: Optional[str] = Query(None)):
+    """Get current crop prices from seeded data"""
+    try:
+        ref = get_db_ref("market_data/latest")
+        data = ref.get()
+        
+        if not data:
+            raise HTTPException(status_code=404, detail="No market data. Please seed database first.")
+        
+        if crop:
+            price = data.get("prices", {}).get(crop)
+            if not price:
+                raise HTTPException(status_code=404, detail=f"No price data for {crop}")
+            return {
+                "crop": crop,
+                "price": price,
+                "unit": "PKR per 40kg",
+                "timestamp": data.get("timestamp")
+            }
+        
+        return data
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/market/prices/history/{crop}", tags=["market-data"])
+async def get_crop_price_history(
+    crop: str,
+    days: int = Query(30, ge=1, le=90)
+):
+    """Get price history for a specific crop"""
+    try:
+        from ageents.marketAgent import get_historical_prices
+        
+        history = await get_historical_prices(crop, days)
+        
+        if history.get("error"):
+            raise HTTPException(status_code=404, detail=history["error"])
+        
+        return {
+            "crop": crop,
+            "period_days": days,
+            "data_points": history.get("data_points", []),
+            "total_records": history.get("total_records", 0)
+        }
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/market/analytics/{crop}", tags=["market-data"])
+async def get_crop_analytics(
+    crop: str,
+    days: int = Query(7, ge=1, le=90)
+):
+    """Get analytical insights for a crop"""
+    try:
+        from ageents.marketAgent import calculate_price_trend
+        
+        trend_data = await calculate_price_trend(crop, days)
+        
+        if trend_data.get("error"):
+            raise HTTPException(status_code=404, detail=trend_data["error"])
+        
+        return trend_data
+        
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/market/crops", tags=["market-data"])
+async def list_available_crops():
+    """List all available crops with data"""
+    try:
+        ref = get_db_ref("market_data/latest")
+        data = ref.get()
+        
+        if not data or "prices" not in data:
+            return {"crops": [], "message": "No data available. Please seed database."}
+        
+        crops = []
+        for crop, price in data["prices"].items():
+            crops.append({
+                "name": crop,
+                "current_price": price,
+                "unit": "PKR per 40kg"
+            })
+        
+        return {"crops": crops, "total": len(crops)}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    
+# ---------------- WEATHER + SOIL ENDPOINTS ----------------
+from ageents.weatherAgent import run_weather_agent, fetch_current, fetch_forecast
+from ageents.soilAgent import run_soil_agent
+from ageents.predictionAgent import run_prediction_workflow
+from soil_data_seeder import seed_200_soil_entries, verify_soil_data  # import soil functions
+from fastapi import Query
+from pydantic import BaseModel
+
+
+# ---------------- Request/Response Models ----------------
+class PredictionRequest(BaseModel):
+    location: str
+    crop: str
+    city: Optional[str] = None
+
+class MultiLocationRequest(BaseModel):
+    locations: List[str]
+    crop: Optional[str] = None
+
+# ============================================================
+# WEATHER ENDPOINTS
+# ============================================================
+
+@app.get("/weather", tags=["weather"])
+async def get_weather(city: str = Query(..., description="City name for weather data")):
+    """Get current and forecast weather for a given city with AI analysis"""
+    try:
+        result = await run_weather_agent(city)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Weather error: {str(e)}")
+
+@app.get("/weather/summary", tags=["weather"])
+async def weather_summary(city: str = Query(..., description="City name for summary")):
+    """Short summary of weather trend and recommendations"""
+    try:
+        result = await run_weather_agent(city)
+        summary = {
+            "city": result.get("city"),
+            "trend": result.get("trend"),
+            "precipitation_chance": result.get("precipitation_chance"),
+            "recommendations": result.get("recommendations"),
+        }
+        return summary
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Weather summary error: {str(e)}")
+
+@app.get("/weather/raw", tags=["weather"])
+def get_raw_weather(city: str = Query(...)):
+    """Raw OpenWeatherMap current + forecast (no AI processing)"""
+    try:
+        current = fetch_current(city)
+        forecast = fetch_forecast(city)
+        return {"current": current, "forecast": forecast}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Raw weather error: {str(e)}")
+
+@app.get("/weather/forecast", tags=["weather"])
+async def get_weather_forecast(
+    city: str = Query(..., description="City name for forecast"),
+    days: int = Query(3, ge=1, le=7, description="Number of days for forecast (1–7)")
+):
+    """
+    Get detailed weather forecast every 3 hours for the next N days.
+    Uses OpenWeatherMap 3-hour forecast data.
+    """
+    try:
+        forecast_data = fetch_forecast(city)
+        
+        if not forecast_data or "list" not in forecast_data:
+            raise HTTPException(status_code=404, detail="Forecast data unavailable for this city")
+
+        filtered_forecast = []
+        for item in forecast_data["list"]:
+            timestamp = item["dt_txt"]
+            temp = item["main"]["temp"]
+            humidity = item["main"]["humidity"]
+            weather_desc = item["weather"][0]["description"]
+            wind_speed = item["wind"]["speed"]
+
+            filtered_forecast.append({
+                "time": timestamp,
+                "temperature": round(temp, 1),
+                "humidity": humidity,
+                "description": weather_desc.capitalize(),
+                "wind_speed": wind_speed
+            })
+
+        # Limit to N days (8 entries per day × days)
+        limit = days * 8
+        return {
+            "city": city,
+            "forecast_hours": len(filtered_forecast[:limit]),
+            "data": filtered_forecast[:limit],
+            "unit": "Celsius",
+            "source": "OpenWeatherMap"
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Forecast error: {str(e)}")
+
+@app.post("/weather/multi", tags=["weather"])
+async def get_multiple_weather(cities: List[str]):
+    """Batch weather insights for multiple cities"""
+    results = {}
+    for city in cities:
+        try:
+            results[city] = await run_weather_agent(city)
+        except Exception as e:
+            results[city] = {"error": str(e)}
+    return results
+
+# ============================================================
+# SOIL ENDPOINTS
+# ============================================================
+
+@app.get("/soil", tags=["soil"])
+async def get_soil_analysis(
+    location: str = Query(..., description="Location name for soil data"),
+    crop: Optional[str] = Query(None, description="Optional: specific crop for analysis")
+):
+    """Get comprehensive soil analysis for a location"""
+    try:
+        result = await run_soil_agent(location, crop)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Soil analysis error: {str(e)}")
+
+@app.get("/soil/summary", tags=["soil"])
+async def get_soil_summary(
+    location: str = Query(..., description="Location name"),
+    crop: Optional[str] = Query(None, description="Optional: crop name")
+):
+    """Short summary of soil health and recommendations"""
+    try:
+        result = await run_soil_agent(location, crop)
+        summary = {
+            "location": result.get("location"),
+            "crop": result.get("crop"),
+            "soil_health_score": result.get("soil_health_score"),
+            "nutrient_status": result.get("nutrient_status"),
+            "warnings": result.get("warnings"),
+            "recommendations": result.get("recommendations")[:3]  # Top 3
+        }
+        return summary
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Soil summary error: {str(e)}")
+
+@app.get("/soil/nutrients", tags=["soil"])
+async def get_nutrient_status(
+    location: str = Query(..., description="Location name"),
+    crop: Optional[str] = Query(None, description="Optional: crop name")
+):
+    """Get detailed nutrient status and fertilizer recommendations"""
+    try:
+        result = await run_soil_agent(location, crop)
+        return {
+            "location": result.get("location"),
+            "nutrient_status": result.get("nutrient_status"),
+            "fertilizer_plan": result.get("fertilizer_plan"),
+            "deficiencies": result.get("deficiencies"),
+            "soil_health_score": result.get("soil_health_score")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Nutrient analysis error: {str(e)}")
+
+@app.get("/soil/irrigation", tags=["soil"])
+async def get_irrigation_advice(
+    location: str = Query(..., description="Location name"),
+    crop: Optional[str] = Query(None, description="Optional: crop name")
+):
+    """Get irrigation recommendations based on soil moisture"""
+    try:
+        result = await run_soil_agent(location, crop)
+        soil_data = result.get("soil_data", {})
+        return {
+            "location": result.get("location"),
+            "irrigation_advice": result.get("irrigation_advice"),
+            "current_moisture": soil_data.get("moisture_percent"),
+            "optimal_range": "15-25%",
+            "recommendations": [r for r in result.get("recommendations", []) if "irrigation" in r.lower()]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Irrigation advice error: {str(e)}")
+
+@app.post("/soil/multi", tags=["soil"])
+async def get_multiple_soil_analysis(request: MultiLocationRequest):
+    """Batch soil analysis for multiple locations"""
+    results = {}
+    for location in request.locations:
+        try:
+            results[location] = await run_soil_agent(location, request.crop)
+        except Exception as e:
+            results[location] = {"error": str(e)}
+    return results
+
+@app.post("/seed-soil", tags=["soil"])
+async def seed_soil():
+    """Seed 200 soil data entries into Firebase"""
+    try:
+        entries = seed_200_soil_entries()
+        return {
+            "status": "success",
+            "entries_created": len(entries),
+            "message": "Soil database seeded successfully"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Soil seeding error: {str(e)}")
+
+@app.get("/verify-soil", tags=["soil"])
+async def verify_soil():
+    """Verify soil data integrity in Firebase"""
+    try:
+        verify_soil_data()
+        return {"status": "verification complete", "message": "Soil data verified successfully"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Soil verification error: {str(e)}")
+
+# ============================================================
+# PREDICTION WORKFLOW ENDPOINTS
+# ============================================================
+
+@app.post("/prediction", tags=["prediction"])
+async def get_farm_prediction(request: PredictionRequest):
+    """
+    Get comprehensive farm prediction by combining weather and soil analysis.
+    This is the main workflow endpoint that orchestrates multiple agents.
+    """
+    try:
+        result = await run_prediction_workflow(
+            location=request.location,
+            crop=request.crop,
+            city=request.city
+        )
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Prediction workflow error: {str(e)}")
+
+@app.get("/prediction/quick", tags=["prediction"])
+async def get_quick_prediction(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather (optional)")
+):
+    """Quick prediction summary (faster response, less detail)"""
+    try:
+        result = await run_prediction_workflow(location, crop, city)
+        
+        # Return only essential information
+        quick_summary = {
+            "location": result.get("location"),
+            "crop": result.get("crop"),
+            "risk_level": result.get("risk_level"),
+            "success_probability": result.get("success_probability"),
+            "immediate_actions": result.get("immediate_actions", [])[:3],
+            "executive_summary": result.get("executive_summary")
+        }
+        return quick_summary
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Quick prediction error: {str(e)}")
+
+@app.get("/prediction/detailed", tags=["prediction"])
+async def get_detailed_prediction(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather (optional)")
+):
+    """Detailed prediction with complete weather and soil data"""
+    try:
+        result = await run_prediction_workflow(location, crop, city)
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Detailed prediction error: {str(e)}")
+
+@app.get("/prediction/actions", tags=["prediction"])
+async def get_action_plan(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather (optional)")
+):
+    """Get time-based action plan (immediate/short-term/long-term)"""
+    try:
+        result = await run_prediction_workflow(location, crop, city)
+        
+        return {
+            "location": result.get("location"),
+            "crop": result.get("crop"),
+            "risk_level": result.get("risk_level"),
+            "immediate_actions": result.get("immediate_actions", []),
+            "short_term_actions": result.get("short_term_actions", []),
+            "long_term_actions": result.get("long_term_actions", []),
+            "irrigation_schedule": result.get("irrigation_schedule"),
+            "fertilizer_schedule": result.get("fertilizer_schedule")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Action plan error: {str(e)}")
+
+@app.get("/prediction/risks", tags=["prediction"])
+async def get_risk_assessment(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather (optional)")
+):
+    """Get comprehensive risk assessment"""
+    try:
+        result = await run_prediction_workflow(location, crop, city)
+        
+        return {
+            "location": result.get("location"),
+            "crop": result.get("crop"),
+            "risk_level": result.get("risk_level"),
+            "success_probability": result.get("success_probability"),
+            "weather_risks": result.get("weather_risks", []),
+            "soil_risks": result.get("soil_risks", []),
+            "pest_disease_risk": result.get("pest_disease_risk"),
+            "mitigation_actions": result.get("immediate_actions", [])
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Risk assessment error: {str(e)}")
+
+@app.post("/prediction/batch", tags=["prediction"])
+async def batch_predictions(locations: List[str], crop: str):
+    """Run predictions for multiple locations with the same crop"""
+    results = {}
+    for location in locations:
+        try:
+            result = await run_prediction_workflow(location, crop)
+            results[location] = {
+                "risk_level": result.get("risk_level"),
+                "success_probability": result.get("success_probability"),
+                "executive_summary": result.get("executive_summary")
+            }
+        except Exception as e:
+            results[location] = {"error": str(e)}
+    return results
+
+# ============================================================
+# INTEGRATED ENDPOINTS (Weather + Soil Combined)
+# ============================================================
+
+@app.get("/integrated/overview", tags=["integrated"])
+async def get_integrated_overview(
+    location: str = Query(..., description="Location name"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """Get side-by-side weather and soil overview (without prediction synthesis)"""
+    try:
+        weather_city = city or location
+        
+        # Fetch both in parallel
+        import asyncio
+        weather_task = run_weather_agent(weather_city)
+        soil_task = run_soil_agent(location, crop)
+        
+        weather_result, soil_result = await asyncio.gather(weather_task, soil_task)
+        
+        return {
+            "location": location,
+            "crop": crop,
+            "weather": {
+                "city": weather_result.get("city"),
+                "trend": weather_result.get("trend"),
+                "precipitation_chance": weather_result.get("precipitation_chance"),
+                "recommendations": weather_result.get("recommendations")
+            },
+            "soil": {
+                "health_score": soil_result.get("soil_health_score"),
+                "nutrient_status": soil_result.get("nutrient_status"),
+                "warnings": soil_result.get("warnings"),
+                "recommendations": soil_result.get("recommendations")
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Integrated overview error: {str(e)}")
+    
+# ---------------- ADVISORY ENDPOINTS ----------------
+# Add these to your main FastAPI app file (after the prediction endpoints)
+
+from ageents.advisoryAgent import run_advisory_agent
+from pydantic import BaseModel
+
+class AdvisoryRequest(BaseModel):
+    location: str
+    crop: str
+    city: Optional[str] = None
+    language: Optional[str] = "english"  # Future: support multiple languages
+
+# ============================================================
+# ADVISORY ENDPOINTS
+# ============================================================
+
+@app.post("/advisory", tags=["advisory"])
+async def get_farm_advisory(request: AdvisoryRequest):
+    """
+    Get comprehensive farmer-friendly advisory.
+    Transforms raw prediction data into actionable, easy-to-understand advice.
+    """
+    try:
+        result = await run_advisory_agent(
+            location=request.location,
+            crop=request.crop,
+            city=request.city
+        )
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Advisory generation error: {str(e)}")
+
+@app.get("/advisory/quick", tags=["advisory"])
+async def get_quick_advisory(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Quick advisory summary - just the essentials for busy farmers.
+    Returns: status, urgent actions, and key recommendations.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        quick_summary = {
+            "status_emoji": result.get("status_emoji"),
+            "status_message": result.get("status_message"),
+            "situation_summary": result.get("situation_summary"),
+            "urgent_today": result.get("urgent_today", []),
+            "irrigation_guidance": result.get("irrigation_guidance"),
+            "pest_risk_level": result.get("pest_risk_level"),
+            "key_reminders": result.get("key_reminders", [])
+        }
+        return quick_summary
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Quick advisory error: {str(e)}")
+
+@app.get("/advisory/actions", tags=["advisory"])
+async def get_action_checklist(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Get time-based action checklist in simple language.
+    Perfect for farmers who want a clear to-do list.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        return {
+            "farm_name": result.get("farm_name"),
+            "advisory_date": result.get("advisory_date"),
+            "status": {
+                "emoji": result.get("status_emoji"),
+                "message": result.get("status_message")
+            },
+            "actions": {
+                "urgent_today": result.get("urgent_today", []),
+                "this_week": result.get("this_week", []),
+                "plan_ahead": result.get("plan_ahead", [])
+            },
+            "next_check": result.get("next_advisory_date")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Action checklist error: {str(e)}")
+
+@app.get("/advisory/weather-tips", tags=["advisory"])
+async def get_weather_tips(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Get weather-specific guidance and tips.
+    Explains how weather will affect the crop and what to do.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        return {
+            "location": result.get("farm_name"),
+            "crop": crop,
+            "weather_outlook": result.get("weather_outlook"),
+            "weather_impact": result.get("weather_impact"),
+            "weather_tips": result.get("weather_tips", []),
+            "irrigation_guidance": result.get("irrigation_guidance"),
+            "water_saving_tips": result.get("water_saving_tips", [])
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Weather tips error: {str(e)}")
+
+@app.get("/advisory/soil-nutrition", tags=["advisory"])
+async def get_soil_nutrition_advice(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Get soil health and nutrition advice in simple terms.
+    Tells farmers what their soil needs and how to improve it.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        return {
+            "location": result.get("farm_name"),
+            "crop": crop,
+            "soil_health_status": result.get("soil_health_status"),
+            "nutrition_advice": result.get("nutrition_advice"),
+            "soil_tips": result.get("soil_tips", []),
+            "cost_saving_opportunities": result.get("cost_saving_opportunities", [])
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Soil nutrition advice error: {str(e)}")
+
+@app.get("/advisory/pest-disease", tags=["advisory"])
+async def get_pest_disease_advisory(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Get pest and disease prevention advice.
+    Helps farmers protect their crops proactively.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        return {
+            "location": result.get("farm_name"),
+            "crop": crop,
+            "pest_risk_level": result.get("pest_risk_level"),
+            "pest_advice": result.get("pest_advice"),
+            "prevention_steps": result.get("prevention_steps", []),
+            "what_to_watch": "Check crops regularly for unusual spots, holes, or wilting"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Pest advisory error: {str(e)}")
+
+@app.get("/advisory/harvest", tags=["advisory"])
+async def get_harvest_advisory(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Get harvest planning and timing advice.
+    Helps farmers know when and how to harvest for best results.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        return {
+            "location": result.get("farm_name"),
+            "crop": crop,
+            "harvest_readiness": result.get("harvest_readiness"),
+            "harvest_timing": result.get("harvest_timing"),
+            "harvest_tips": result.get("harvest_tips", []),
+            "yield_expectation": result.get("yield_expectation"),
+            "market_advice": result.get("market_advice")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Harvest advisory error: {str(e)}")
+
+@app.get("/advisory/report", tags=["advisory"])
+async def get_advisory_report(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Get complete advisory report formatted for printing or sharing.
+    Perfect for farmers who want a full reference document.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        # Format as a readable report
+        report = {
+            "header": {
+                "title": f"Farm Advisory Report - {result.get('farm_name')}",
+                "date": result.get("advisory_date"),
+                "advisory_id": result.get("advisory_id"),
+                "crop": crop
+            },
+            "status": {
+                "emoji": result.get("status_emoji"),
+                "message": result.get("status_message"),
+                "confidence": result.get("confidence_level")
+            },
+            "overview": {
+                "situation": result.get("situation_summary"),
+                "meaning": result.get("what_it_means")
+            },
+            "action_plan": {
+                "urgent": result.get("urgent_today", []),
+                "this_week": result.get("this_week", []),
+                "long_term": result.get("plan_ahead", [])
+            },
+            "weather_section": {
+                "outlook": result.get("weather_outlook"),
+                "impact": result.get("weather_impact"),
+                "tips": result.get("weather_tips", [])
+            },
+            "soil_section": {
+                "health": result.get("soil_health_status"),
+                "advice": result.get("nutrition_advice"),
+                "tips": result.get("soil_tips", [])
+            },
+            "water_management": {
+                "irrigation": result.get("irrigation_guidance"),
+                "savings": result.get("water_saving_tips", [])
+            },
+            "pest_disease": {
+                "risk_level": result.get("pest_risk_level"),
+                "advice": result.get("pest_advice"),
+                "prevention": result.get("prevention_steps", [])
+            },
+            "harvest_planning": {
+                "readiness": result.get("harvest_readiness"),
+                "timing": result.get("harvest_timing"),
+                "tips": result.get("harvest_tips", []),
+                "yield_expectation": result.get("yield_expectation")
+            },
+            "progress_report": {
+                "going_well": result.get("what_going_well", []),
+                "improve": result.get("areas_to_improve", [])
+            },
+            "support": {
+                "resources": result.get("helpful_resources", []),
+                "contact": result.get("contact_support")
+            },
+            "footer": {
+                "next_check": result.get("next_advisory_date"),
+                "key_reminders": result.get("key_reminders", [])
+            }
+        }
+        
+        return report
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Advisory report error: {str(e)}")
+
+@app.post("/advisory/compare", tags=["advisory"])
+async def compare_advisories(locations: List[str], crop: str):
+    """
+    Compare advisories for multiple locations.
+    Useful for farmers with multiple plots or cooperatives.
+    """
+    results = {}
+    for location in locations:
+        try:
+            advisory = await run_advisory_agent(location, crop)
+            results[location] = {
+                "status": advisory.get("status_message"),
+                "risk_emoji": advisory.get("status_emoji"),
+                "urgent_actions": advisory.get("urgent_today", []),
+                "irrigation": advisory.get("irrigation_guidance"),
+                "pest_risk": advisory.get("pest_risk_level")
+            }
+        except Exception as e:
+            results[location] = {"error": str(e)}
+    
+    return {
+        "crop": crop,
+        "comparison_date": datetime.now().strftime("%B %d, %Y"),
+        "locations": results
+    }
+
+@app.get("/advisory/sms-format", tags=["advisory"])
+async def get_sms_advisory(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Get ultra-short advisory formatted for SMS (160 characters).
+    Perfect for farmers with basic phones or limited data.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        # Create ultra-short SMS message
+        status = result.get("status_emoji", "")
+        urgent = result.get("urgent_today", ["Check farm"])[0][:60]
+        irrigation = result.get("irrigation_guidance", "")[:40]
+        
+        sms_message = f"{status} {crop} at {location}: {urgent}. Water: {irrigation}"
+        
+        # Truncate to 160 chars
+        sms_message = sms_message[:160]
+        
+        return {
+            "sms_text": sms_message,
+            "character_count": len(sms_message),
+            "full_advisory_url": f"/advisory?location={location}&crop={crop}"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"SMS advisory error: {str(e)}")
+
+@app.get("/advisory/voice", tags=["advisory"])
+async def get_voice_advisory(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Get advisory formatted for voice/audio output.
+    Optimized for text-to-speech systems or voice calls.
+    """
+    try:
+        result = await run_advisory_agent(location, crop, city)
+        
+        # Create voice-friendly script
+        voice_script = f"""
+        Hello farmer. This is your advisory for {crop} at {location}.
+        
+        Status: {result.get('status_message', 'Checking conditions')}
+        
+        Here's what you need to know: {result.get('situation_summary', 'Conditions are being monitored')}
+        
+        Important actions for today:
+        """
+        
+        for i, action in enumerate(result.get('urgent_today', [])[:3], 1):
+            voice_script += f"\n{i}. {action}"
+        
+        voice_script += f"\n\nFor watering: {result.get('irrigation_guidance', 'Check soil moisture')}"
+        voice_script += f"\n\nPest risk is: {result.get('pest_risk_level', 'moderate')}. {result.get('pest_advice', 'Monitor your crops')}"
+        voice_script += "\n\nThank you for listening. Check back in a few days for updates."
+        
+        return {
+            "voice_script": voice_script,
+            "estimated_duration_seconds": len(voice_script.split()) * 0.4,  # ~150 words/min
+            "language": "english"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Voice advisory error: {str(e)}")
+
+# ============================================================
+# COMPARISON ENDPOINT: Prediction vs Advisory
+# ============================================================
+
+@app.get("/compare/prediction-advisory", tags=["integrated"])
+async def compare_prediction_and_advisory(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather")
+):
+    """
+    Show side-by-side comparison of raw prediction vs farmer-friendly advisory.
+    Useful for understanding the transformation process.
+    """
+    try:
+        from ageents.predictionAgent import run_prediction_workflow
+        
+        # Get both
+        prediction = await run_prediction_workflow(location, crop, city)
+        advisory = await run_advisory_agent(location, crop, city)
+        
+        return {
+            "location": location,
+            "crop": crop,
+            "comparison": {
+                "raw_prediction": {
+                    "risk_level": prediction.get("risk_level"),
+                    "success_probability": prediction.get("success_probability"),
+                    "immediate_actions": prediction.get("immediate_actions", []),
+                    "executive_summary": prediction.get("executive_summary")
+                },
+                "farmer_advisory": {
+                    "status_message": advisory.get("status_message"),
+                    "situation_summary": advisory.get("situation_summary"),
+                    "urgent_today": advisory.get("urgent_today", []),
+                    "what_it_means": advisory.get("what_it_means")
+                }
+            },
+            "note": "Advisory transforms technical data into farmer-friendly language"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Comparison error: {str(e)}")
+
+from ageents.marketAdvisoryAgent import run_market_advisory
+from pydantic import BaseModel
+from typing import Optional, List
+
+class MarketAdvisoryRequest(BaseModel):
+    crop: str
+    budget: Optional[float] = None
+    land_size: Optional[float] = None
+    risk_tolerance: Optional[str] = None
+
+# ============================================================
+# MARKET ADVISORY ENDPOINTS
+# ============================================================
+
+@app.get("/market-advisory/selling-guide", tags=["market-advisory"])
+async def get_selling_guide(
+    crop: str = Query(..., description="Crop name")
+):
+    """
+    Get complete selling guide with tips, timing, and negotiation advice.
+    Helps farmers get the best price when selling their crop.
+    """
+    try:
+        result = await run_market_advisory(crop)
+        
+        return {
+            "crop": crop,
+            "current_price": result.get("current_price_pkr"),
+            "is_good_time_to_sell": result.get("is_good_price"),
+            "when_to_sell": result.get("when_to_act"),
+            "fair_price_range": result.get("fair_price_range"),
+            "minimum_price": result.get("dont_sell_below"),
+            "target_price": result.get("aim_to_sell_at"),
+            "selling_tips": result.get("selling_tips", []),
+            "market_access_tips": result.get("market_access_tips", []),
+            "transport_costs": result.get("transport_costs"),
+            "cooperative_opportunities": result.get("cooperative_opportunities", [])
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Selling guide error: {str(e)}")
+
+@app.get("/market-advisory/buying-guide", tags=["market-advisory"])
+async def get_buying_guide(
+    crop: str = Query(..., description="Crop name for which to buy inputs")
+):
+    """
+    Get buying guide for agricultural inputs.
+    Helps farmers save money when purchasing seeds, fertilizer, etc.
+    """
+    try:
+        result = await run_market_advisory(crop)
+        
+        return {
+            "crop": crop,
+            "main_advice": result.get("main_action"),
+            "best_time_to_buy": result.get("when_to_act"),
+            "buying_tips": result.get("buying_tips", []),
+            "cooperative_opportunities": result.get("cooperative_opportunities", []),
+            "seasonal_considerations": result.get("seasonal_advice")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Buying guide error: {str(e)}")
+
+@app.get("/market-advisory/sms", tags=["market-advisory"])
+async def get_sms_market_advisory(
+    crop: str = Query(..., description="Crop name")
+):
+    """
+    Get ultra-short market advisory formatted for SMS (160 characters).
+    Perfect for farmers with basic phones or limited data.
+    """
+    try:
+        result = await run_market_advisory(crop)
+        
+        emoji = result.get("decision_emoji", "")
+        action = result.get("main_action", "Check market")[:30]
+        price = result.get("current_price_pkr", 0)
+        direction = result.get("price_direction", "")[:20]
+        
+        sms_text = f"{emoji} {crop.upper()}: {action}. Price: ₨{price:,.0f}. Trend: {direction}"
+        sms_text = sms_text[:160]
+        
+        return {
+            "sms_text": sms_text,
+            "character_count": len(sms_text),
+            "full_advisory_url": f"/market-advisory/quick?crop={crop}"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"SMS advisory error: {str(e)}")
+
+@app.get("/market-advisory/voice", tags=["market-advisory"])
+async def get_voice_market_advisory(
+    crop: str = Query(..., description="Crop name")
+):
+    """
+    Get market advisory formatted for voice/audio output.
+    Optimized for text-to-speech systems or voice calls.
+    """
+    try:
+        result = await run_market_advisory(crop)
+        
+        voice_script = f"""
+        Hello farmer. This is your market advisory for {crop}.
+        
+        Current situation: {result.get('what_happening', 'Market conditions are being analyzed')}
+        
+        Current price is {result.get('current_price_pkr', 0)} rupees per 40 kilograms.
+        Price trend: {result.get('price_direction', 'stable')}
+        
+        My advice: {result.get('main_action', 'Monitor market closely')}
+        
+        Action for today:
+        """
+        
+        for i, action in enumerate(result.get('do_today', [])[:3], 1):
+            voice_script += f"\n{i}. {action}"
+        
+        voice_script += f"\n\nTiming: {result.get('when_to_act', 'Monitor regularly')}"
+        voice_script += f"\n\nBottom line: {result.get('bottom_line', 'Stay informed and act wisely')}"
+        voice_script += "\n\nThank you for listening. Check back regularly for updates."
+        
+        return {
+            "voice_script": voice_script,
+            "estimated_duration_seconds": len(voice_script.split()) * 0.4,
+            "language": "english"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Voice advisory error: {str(e)}")
+
+@app.get("/market-advisory/report", tags=["market-advisory"])
+async def get_market_advisory_report(
+    crop: str = Query(..., description="Crop name"),
+    budget: Optional[float] = Query(None),
+    land_size: Optional[float] = Query(None),
+    risk_tolerance: Optional[str] = Query(None)
+):
+    """
+    Get complete market advisory report formatted for printing or sharing.
+    Perfect for farmers who want a full reference document.
+    """
+    try:
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        if risk_tolerance:
+            farmer_context["risk_tolerance"] = risk_tolerance
+        
+        result = await run_market_advisory(crop, farmer_context or None)
+        
+        report = {
+            "header": {
+                "title": f"Market Advisory Report - {crop.upper()}",
+                "date": result.get("advisory_date"),
+                "advisory_id": result.get("advisory_id")
+            },
+            "decision": {
+                "emoji": result.get("decision_emoji"),
+                "action": result.get("main_action"),
+                "urgency": result.get("urgency_level"),
+                "when": result.get("when_to_act")
+            },
+            "market_situation": {
+                "what_happening": result.get("what_happening"),
+                "why_matters": result.get("why_it_matters"),
+                "best_move": result.get("best_move")
+            },
+            "price_information": {
+                "current_price": result.get("current_price_pkr"),
+                "price_direction": result.get("price_direction"),
+                "price_change": result.get("price_change_description"),
+                "fair_range": result.get("fair_price_range"),
+                "minimum_acceptable": result.get("dont_sell_below"),
+                "target_price": result.get("aim_to_sell_at")
+            },
+            "action_plan": {
+                "today": result.get("do_today", []),
+                "this_week": result.get("do_this_week", []),
+                "future": result.get("plan_ahead", [])
+            },
+            "financial_outlook": {
+                "expected_income": result.get("expected_income_per_acre"),
+                "profit_potential": result.get("profit_potential"),
+                "price_forecast": result.get("price_forecast_simple")
+            },
+            "risks_and_protection": {
+                "risks": result.get("risks_to_watch", []),
+                "protection": result.get("how_to_protect", []),
+                "alternatives": result.get("if_cant_sell_now", [])
+            },
+            "market_context": {
+                "supply": result.get("supply_situation"),
+                "demand": result.get("demand_situation"),
+                "competition": result.get("competition_level"),
+                "seasonal": result.get("seasonal_advice")
+            },
+            "practical_tips": {
+                "selling": result.get("selling_tips", []),
+                "buying": result.get("buying_tips", []),
+                "storage": result.get("storage_advice"),
+                "transport": result.get("transport_costs")
+            },
+            "resources": {
+                "price_sources": result.get("where_to_check_prices", []),
+                "contacts": result.get("who_to_contact", []),
+                "cooperative": result.get("cooperative_opportunities", [])
+            },
+            "summary": {
+                "bottom_line": result.get("bottom_line"),
+                "confidence": result.get("confidence_level")
+            }
+        }
+        
+        return report
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Report generation error: {str(e)}")
+
+@app.post("/market-advisory/compare", tags=["market-advisory"])
+async def compare_market_advisories(
+    crops: List[str],
+    budget: Optional[float] = None,
+    land_size: Optional[float] = None
+):
+    """
+    Compare market advisories for multiple crops.
+    Useful for farmers deciding which crop to plant or sell.
+    """
+    results = {}
+    farmer_context = {}
+    if budget:
+        farmer_context["budget"] = budget
+    if land_size:
+        farmer_context["land_size"] = land_size
+    
+    for crop in crops:
+        try:
+            advisory = await run_market_advisory(crop, farmer_context or None)
+            results[crop] = {
+                "decision": advisory.get("main_action"),
+                "emoji": advisory.get("decision_emoji"),
+                "urgency": advisory.get("urgency_level"),
+                "current_price": advisory.get("current_price_pkr"),
+                "price_direction": advisory.get("price_direction"),
+                "profit_potential": advisory.get("profit_potential"),
+                "when_to_act": advisory.get("when_to_act"),
+                "bottom_line": advisory.get("bottom_line")
+            }
+        except Exception as e:
+            results[crop] = {"error": str(e)}
+    
+    # Determine best option
+    best_crop = None
+    best_score = -1
+    
+    for crop, data in results.items():
+        if "error" not in data:
+            score = 0
+            if "SELL" in data.get("decision", "").upper() and data.get("urgency") == "urgent":
+                score += 3
+            if "going up" in data.get("price_direction", ""):
+                score += 2
+            if data.get("profit_potential") == "Good profit expected":
+                score += 2
+            
+            if score > best_score:
+                best_score = score
+                best_crop = crop
+    
+    return {
+        "comparison_date": datetime.now().strftime("%B %d, %Y"),
+        "farmer_context": farmer_context,
+        "crops": results,
+        "recommendation": f"Based on current conditions, {best_crop} looks most promising" if best_crop else "Monitor all crops closely"
+    }
+
+# ============================================================
+# COMPARISON ENDPOINT: Raw Market vs Advisory
+# ============================================================
+
+@app.get("/compare/market-advisory", tags=["integrated"])
+async def compare_market_and_advisory(
+    crop: str = Query(..., description="Crop name"),
+    budget: Optional[float] = Query(None),
+    land_size: Optional[float] = Query(None)
+):
+    """
+    Show side-by-side comparison of raw market analysis vs farmer-friendly advisory.
+    Useful for understanding the transformation process.
+    """
+    try:
+        from ageents.marketAgent import get_market_advice
+        
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        
+        # Get both
+        raw_market = await get_market_advice(crop, farmer_context or None)
+        advisory = await run_market_advisory(crop, farmer_context or None)
+        
+        return {
+            "crop": crop,
+            "comparison": {
+                "raw_market_analysis": {
+                    "type": "Technical",
+                    "format": "Markdown with data points",
+                    "preview": raw_market[:200] + "..." if len(raw_market) > 200 else raw_market,
+                    "full_length": len(raw_market)
+                },
+                "farmer_advisory": {
+                    "type": "Farmer-Friendly",
+                    "format": "Structured JSON",
+                    "decision": advisory.get("main_action"),
+                    "price": advisory.get("current_price_pkr"),
+                    "bottom_line": advisory.get("bottom_line")
+                }
+            },
+            "transformation_summary": {
+                "technical_to_simple": "Converts percentages to rupee amounts",
+                "action_oriented": "Provides clear YES/NO/WAIT decisions",
+                "practical_focus": "Includes transport, storage, negotiation tips",
+                "money_focused": "Shows expected income per acre"
+            },
+            "note": "Advisory transforms technical market data into actionable farmer advice"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Comparison error: {str(e)}")
+
+# ============================================================
+# INTEGRATED WORKFLOW: Farm Advisory + Market Advisory
+# ============================================================
+
+@app.get("/integrated/complete-advisory", tags=["integrated"])
+async def get_complete_farm_advisory(
+    location: str = Query(..., description="Farm location"),
+    crop: str = Query(..., description="Crop name"),
+    city: Optional[str] = Query(None, description="City for weather"),
+    budget: Optional[float] = Query(None, description="Budget in PKR"),
+    land_size: Optional[float] = Query(None, description="Land size in acres")
+):
+    """
+    Get complete farm advisory: Weather + Soil + Prediction + Market.
+    One-stop endpoint for all farming decisions.
+    """
+    try:
+        from ageents.advisoryAgent import run_advisory_agent
+        
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        
+        # Get farm advisory (weather + soil + prediction)
+        print("📊 Fetching farm advisory...")
+        farm_advisory = await run_advisory_agent(location, crop, city)
+        
+        # Get market advisory
+        print("💰 Fetching market advisory...")
+        market_advisory = await run_market_advisory(crop, farmer_context or None)
+        
+        return {
+            "location": location,
+            "crop": crop,
+            "advisory_date": datetime.now().strftime("%B %d, %Y"),
+            
+            "farm_conditions": {
+                "status": farm_advisory.get("status_message"),
+                "status_emoji": farm_advisory.get("status_emoji"),
+                "situation": farm_advisory.get("situation_summary"),
+                "urgent_actions": farm_advisory.get("urgent_today", []),
+                "irrigation": farm_advisory.get("irrigation_guidance"),
+                "pest_risk": farm_advisory.get("pest_risk_level")
+            },
+            
+            "market_conditions": {
+                "decision": market_advisory.get("main_action"),
+                "decision_emoji": market_advisory.get("decision_emoji"),
+                "current_price": market_advisory.get("current_price_pkr"),
+                "price_direction": market_advisory.get("price_direction"),
+                "when_to_act": market_advisory.get("when_to_act"),
+                "profit_potential": market_advisory.get("profit_potential")
+            },
+            
+            "integrated_recommendations": {
+                "farming_actions": farm_advisory.get("urgent_today", [])[:3],
+                "market_actions": market_advisory.get("do_today", [])[:3],
+                "overall_strategy": combine_advisories(farm_advisory, market_advisory, crop)
+            },
+            
+            "financial_outlook": {
+                "expected_income": market_advisory.get("expected_income_per_acre"),
+                "yield_expectation": farm_advisory.get("yield_expectation"),
+                "success_probability": f"{farm_advisory.get('confidence_level', 'Moderate')} confidence"
+            },
+            
+            "next_steps": {
+                "immediate": "Focus on urgent farming tasks and monitor market prices",
+                "this_week": "Follow irrigation schedule and prepare for selling if advised",
+                "planning": "Consider seasonal patterns and long-term soil improvement"
+            }
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Complete advisory error: {str(e)}")
+
+# ============================================================
+# HELPER FUNCTION
+# ============================================================
+
+def combine_advisories(farm_advisory: dict, market_advisory: dict, crop: str) -> str:
+    """Combine farm and market advisories into integrated strategy"""
+    
+    farm_status = farm_advisory.get("status_emoji", "🟡")
+    market_action = market_advisory.get("main_action", "Monitor")
+    
+    if "🟢" in farm_status and "SELL" in market_action.upper():
+        return f"Perfect timing! Your {crop} is healthy AND market prices are good. Focus on harvest prep and selling."
+    
+    elif "🟡" in farm_status and "SELL" in market_action.upper():
+        return f"Market is good for selling, but improve crop health first. Address urgent farming tasks before harvest."
+    
+    elif "🔴" in farm_status:
+        return f"Priority: Fix crop health issues immediately. Market considerations are secondary until crop improves."
+    
+    elif "WAIT" in market_action.upper() or "HOLD" in market_action.upper():
+        return f"Focus on farming tasks - market timing isn't urgent. Improve yield quality while waiting for better prices."
+    
+    elif "BUY" in market_action.upper():
+        return f"Good time to buy inputs for next season. Meanwhile, maintain current crop properly for decent harvest."
+    
+    else:
+        return f"Balanced approach: Maintain farm health and monitor market conditions regularly.".post("/market-advisory", tags=["market-advisory"])
+async def get_market_advisory(request: MarketAdvisoryRequest):
+    """
+    Get farmer-friendly market advisory (comprehensive).
+    Transforms raw market data into practical, money-focused advice.
+    """
+    try:
+        farmer_context = {}
+        if request.budget:
+            farmer_context["budget"] = request.budget
+        if request.land_size:
+            farmer_context["land_size"] = request.land_size
+        if request.risk_tolerance:
+            farmer_context["risk_tolerance"] = request.risk_tolerance
+        
+        result = await run_market_advisory(
+            crop=request.crop,
+            farmer_context=farmer_context or None
+        )
+        return result
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Market advisory error: {str(e)}")
+
+@app.get("/market-advisory/quick", tags=["market-advisory"])
+async def get_quick_market_advisory(
+    crop: str = Query(..., description="Crop name"),
+    budget: Optional[float] = Query(None, description="Budget in PKR"),
+    land_size: Optional[float] = Query(None, description="Land size in acres"),
+    risk_tolerance: Optional[str] = Query(None, description="low, medium, or high")
+):
+    """
+    Quick market advisory - just the essentials for busy farmers.
+    Returns: decision, current price, urgency, and top 3 actions.
+    """
+    try:
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        if risk_tolerance:
+            farmer_context["risk_tolerance"] = risk_tolerance
+        
+        result = await run_market_advisory(crop, farmer_context or None)
+        
+        quick_summary = {
+            "decision_emoji": result.get("decision_emoji"),
+            "main_action": result.get("main_action"),
+            "urgency_level": result.get("urgency_level"),
+            "current_price_pkr": result.get("current_price_pkr"),
+            "price_direction": result.get("price_direction"),
+            "when_to_act": result.get("when_to_act"),
+            "do_today": result.get("do_today", [])[:3],
+            "bottom_line": result.get("bottom_line")
+        }
+        return quick_summary
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Quick advisory error: {str(e)}")
+
+@app.get("/market-advisory/decision", tags=["market-advisory"])
+async def get_market_decision(
+    crop: str = Query(..., description="Crop name"),
+    budget: Optional[float] = Query(None),
+    land_size: Optional[float] = Query(None)
+):
+    """
+    Get simple YES/NO/WAIT decision for selling or buying.
+    Perfect for farmers who just need a quick answer.
+    """
+    try:
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        
+        result = await run_market_advisory(crop, farmer_context or None)
+        
+        return {
+            "crop": crop,
+            "decision": result.get("main_action"),
+            "emoji": result.get("decision_emoji"),
+            "urgency": result.get("urgency_level"),
+            "simple_explanation": result.get("why_it_matters"),
+            "when": result.get("when_to_act")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Decision error: {str(e)}")
+
+@app.get("/market-advisory/price-info", tags=["market-advisory"])
+async def get_price_information(
+    crop: str = Query(..., description="Crop name")
+):
+    """
+    Get detailed price information and negotiation guidance.
+    Includes fair price range, minimum acceptable price, and selling tips.
+    """
+    try:
+        result = await run_market_advisory(crop)
+        
+        return {
+            "crop": crop,
+            "current_price": result.get("current_price_pkr"),
+            "price_direction": result.get("price_direction"),
+            "price_change": result.get("price_change_description"),
+            "is_good_price": result.get("is_good_price"),
+            "fair_price_range": result.get("fair_price_range"),
+            "dont_sell_below": result.get("dont_sell_below"),
+            "aim_to_sell_at": result.get("aim_to_sell_at"),
+            "compared_to_last_week": result.get("compared_to_last_week"),
+            "compared_to_last_month": result.get("compared_to_last_month"),
+            "selling_tips": result.get("selling_tips", [])
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Price info error: {str(e)}")
+
+@app.get("/market-advisory/action-plan", tags=["market-advisory"])
+async def get_action_plan(
+    crop: str = Query(..., description="Crop name"),
+    budget: Optional[float] = Query(None),
+    land_size: Optional[float] = Query(None)
+):
+    """
+    Get time-based action plan: today, this week, and future planning.
+    Clear checklist format for farmers.
+    """
+    try:
+        farmer_context = {}
+        if budget:
+            farmer_context["budget"] = budget
+        if land_size:
+            farmer_context["land_size"] = land_size
+        
+        result = await run_market_advisory(crop, farmer_context or None)
+        
+        return {
+            "crop": crop,
+            "main_action": result.get("main_action"),
+            "urgency": result.get("urgency_level"),
+            "actions": {
+                "do_today": result.get("do_today", []),
+                "do_this_week": result.get("do_this_week", []),
+                "plan_ahead": result.get("plan_ahead", [])
+            },
+            "when_to_act": result.get("when_to_act")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Action plan error: {str(e)}")
+
+@app.get("/market-advisory/profit-potential", tags=["market-advisory"])
+async def get_profit_potential(
+    crop: str = Query(..., description="Crop name"),
+    land_size: float = Query(..., description="Land size in acres")
+):
+    """
+    Get profit potential analysis based on current prices.
+    Shows expected income per acre and profit potential.
+    """
+    try:
+        farmer_context = {"land_size": land_size}
+        result = await run_market_advisory(crop, farmer_context)
+        
+        return {
+            "crop": crop,
+            "land_size_acres": land_size,
+            "current_price_pkr": result.get("current_price_pkr"),
+            "expected_income_per_acre": result.get("expected_income_per_acre"),
+            "profit_potential": result.get("profit_potential"),
+            "price_forecast": result.get("price_forecast_simple"),
+            "best_move": result.get("best_move")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Profit analysis error: {str(e)}")
+
+@app.get("/market-advisory/risks", tags=["market-advisory"])
+async def get_market_risks(
+    crop: str = Query(..., description="Crop name")
+):
+    """
+    Get risk assessment and protection strategies.
+    Warns farmers about potential problems and how to avoid them.
+    """
+    try:
+        result = await run_market_advisory(crop)
+        
+        return {
+            "crop": crop,
+            "main_action": result.get("main_action"),
+            "risks_to_watch": result.get("risks_to_watch", []),
+            "how_to_protect": result.get("how_to_protect", []),
+            "if_cant_sell_now": result.get("if_cant_sell_now", []),
+            "storage_advice": result.get("storage_advice"),
+            "confidence_level": result.get("confidence_level")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Risk assessment error: {str(e)}")
+
+@app.get("/market-advisory/seasonal", tags=["market-advisory"])
+async def get_seasonal_market_advice(
+    crop: str = Query(..., description="Crop name")
+):
+    """
+    Get seasonal market advice and timing guidance.
+    Explains how seasons affect prices and when to act.
+    """
+    try:
+        result = await run_market_advisory(crop)
+        
+        return {
+            "crop": crop,
+            "seasonal_advice": result.get("seasonal_advice"),
+            "upcoming_events": result.get("upcoming_events", []),
+            "when_to_act": result.get("when_to_act"),
+            "supply_situation": result.get("supply_situation"),
+            "demand_situation": result.get("demand_situation"),
+            "competition_level": result.get("competition_level")
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Seasonal advice error: {str(e)}")
+
+# ================== ADMIN ENDPOINTS ==================
+
+@app.post("/admin/seed-entries", tags=["admin"])
+async def seed_sample_entries(count: int = Query(50, ge=10, le=200)):
+    """Seed sample ledger entries for testing"""
+    try:
+        import random
+        from datetime import timedelta
+        
+        categories = ["seeds", "fertilizer", "pesticide", "labor", "equipment", "crop_sale", "other"]
+        payment_methods = ["cash", "bank_transfer", "mobile_money"]
+        
+        ref = get_db_ref("entries")
+        created_count = 0
+        
+        for i in range(count):
+            entry_type = random.choice(["income", "expense"])
+            category = random.choice(categories)
+            
+            # Generate realistic amounts
+            if entry_type == "income":
+                amount = round(random.uniform(5000, 50000), 2)
+            else:
+                amount = round(random.uniform(500, 15000), 2)
+            
+            # Random date in last 60 days
+            days_ago = random.randint(0, 60)
+            created_at = (datetime.now() - timedelta(days=days_ago)).isoformat()
+            
+            entry_id = generate_short_id(7)
+            entry = {
+                "type": "entry",
+                "entryType": entry_type,
+                "category": category,
+                "amount": amount,
+                "currency": "PKR",
+                "paymentMethod": random.choice(payment_methods),
+                "notes": f"Sample {entry_type} entry for testing",
+                "createdAt": created_at,
+                "recordedBy": "seed_script",
+                "deviceId": "seeder",
+                "syncStatus": "synced",
+                "meta": None
+            }
+            
+            ref.child(entry_id).set(entry)
+            created_count += 1
+        
+        return {
+            "status": "success",
+            "message": f"Created {created_count} sample entries",
+            "count": created_count
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/admin/seed-market-data", response_model=InitializationResponse, tags=["admin"])
+async def seed_market_data():
+    """Seed 200 market price entries"""
+    try:
+        # Import and run the seed script
+        from seed_market_data import seed_200_entries
+        
+        entries = seed_200_entries()
+        
+        return InitializationResponse(
+            status="success",
+            message=f"Successfully seeded {len(entries)} market price entries",
+            records_created=len(entries),
+            timestamp=datetime.utcnow().isoformat()
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Seeding error: {str(e)}")
+
+
+@app.delete("/admin/clear-entries", tags=["admin"])
+async def clear_all_entries():
+    """Clear all ledger entries (use with caution!)"""
+    try:
+        ref = get_db_ref("entries")
+        ref.delete()
+        return {"message": "All entries cleared", "status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/admin/clear-market-data", tags=["admin"])
+async def clear_market_data():
+    """Clear all market data (use with caution!)"""
+    try:
+        ref = get_db_ref("market_data")
+        ref.delete()
+        return {"message": "All market data cleared", "status": "success"}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ================== SYSTEM ENDPOINTS ==================
+
+@app.get("/health", response_model=HealthStatus, tags=["system"])
+async def health_check():
+    """Comprehensive health check"""
+    try:
+        # Check Firebase connection
+        ref = get_db_ref("market_data/latest")
+        latest = ref.get()
+        
+        # Check entries
+        entries_ref = get_db_ref("entries")
+        entries = entries_ref.get() or {}
+        
+        # Check market data
+        prices_ref = get_db_ref("market_data/prices")
+        prices = prices_ref.get() or {}
+        
+        market_data_age = "unknown"
+        if latest and "timestamp" in latest:
+            try:
+                ts = datetime.fromisoformat(latest["timestamp"].replace('Z', '+00:00'))
+                age_hours = (datetime.utcnow() - ts).total_seconds() / 3600
+                market_data_age = f"{age_hours:.1f} hours ago"
+            except:
+                pass
+        
+        # Count historical records
+        historical_count = 0
+        for crop_data in prices.values():
+            if isinstance(crop_data, dict):
+                for date_data in crop_data.values():
+                    if isinstance(date_data, dict):
+                        historical_count += len(date_data)
+        
+        return HealthStatus(
+            status="healthy",
+            timestamp=datetime.utcnow().isoformat(),
+            services={
+                "firebase": "connected",
+                "market_agent": "active",
+                "entries": f"{len(entries)} records"
+            },
+            market_data_age=market_data_age,
+            historical_records=historical_count
+        )
+    except Exception as e:
+        return HealthStatus(
+            status="degraded",
+            timestamp=datetime.utcnow().isoformat(),
+            services={
+                "firebase": f"error: {str(e)}",
+                "market_agent": "unknown",
+                "entries": "unknown"
+            }
+        )
+
+
+@app.get("/", tags=["system"])
+async def root():
+    """API information"""
+    return {
+        "name": "AgriLedger+ API",
+        "version": "3.0.0",
+        "description": "AI-powered agricultural ledger and market advisory system",
+        "endpoints": {
+            "entries": "/entries",
+            "market_advice": "/advice/{crop}",
+            "market_summary": "/advice/summary/all",
+            "current_prices": "/market/prices/current",
+            "price_history": "/market/prices/history/{crop}",
+            "analytics": "/market/analytics/{crop}",
+            "health": "/health",
+            "docs": "/docs"
+        },
+        "supported_crops": ["wheat", "rice", "maize", "cotton", "sugarcane", "potato", "onion", "tomato"],
+        "features": [
+            "Voice-enabled ledger entries",
+            "AI market advisory",
+            "Historical price analysis",
+            "Seasonal context",
+            "Multi-crop support"
+        ],
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
+
+# ================== RUN APP ==================
+
+def main():
+    import uvicorn
+    port = int(os.getenv("PORT", "8000"))
+    uvicorn.run(app, host="0.0.0.0", port=port)
+
+
+if __name__ == "__main__":
+    main()
+
+handler = app

models/__init__.py

@@ -0,0 +1,7 @@
+from .expense import EntryMeta, EntryCreate, EntryResponse
+
+__all__ = [
+    "EntryMeta",
+    "EntryCreate",
+    "EntryResponse",
+]

models/expense.py

@@ -0,0 +1,36 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+
+class EntryMeta(BaseModel):
+    voiceText: Optional[str] = None
+    asrConfidence: Optional[float] = Field(default=None, ge=0, le=1)
+    lang: Optional[str] = None
+
+
+class EntryCreate(BaseModel):
+    entryType: str  # "expense" or "income"
+    category: str
+    amount: float
+    date: Optional[str] = None  # ISO string from client; falls back to server time
+    currency: str = Field(default="PKR", min_length=1)
+    paymentMethod: str = Field(default="cash")
+    notes: Optional[str] = None
+    recordedBy: str  # <-- changed to free string (user id, username, etc.)
+    deviceId: Optional[str] = None
+    meta: Optional[EntryMeta] = None
+
+
+class EntryResponse(BaseModel):
+    id: str 
+    type: str = Field(default="entry")
+    entryType: str
+    category: str
+    amount: float
+    currency: str
+    paymentMethod: str
+    notes: Optional[str]
+    createdAt: str
+    recordedBy: str   # <-- free string allowed here too
+    deviceId: Optional[str]
+    syncStatus: str = Field(default="local")
+    meta: Optional[EntryMeta]

models/market.py

@@ -0,0 +1,100 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+# -------------------- Market Data Models --------------------
+class MarketData(BaseModel):
+    crop: str
+    price: float
+    currency: str = "PKR"
+    timestamp: Optional[str] = None
+
+class PriceTrend(BaseModel):
+    crop: str
+    trend: str  # rising, falling, stable
+    percent_change: float
+    current_price: float
+    starting_price: float
+    volatility: str  # low, moderate, high
+    avg_volatility: float
+    confidence: str  # low, medium, high
+    data_points: int
+    analysis_period: str
+    price_history: Optional[List[float]] = None
+
+class SeasonalContext(BaseModel):
+    crop: str
+    current_month: int
+    in_planting_season: bool
+    in_harvest_season: bool
+    months_to_planting: int
+    months_to_harvest: int
+    seasonal_advice: str
+
+# -------------------- Advice Request/Response Models --------------------
+class AdviceRequest(BaseModel):
+    crop: str
+    risk_tolerance: Optional[str] = Field(None, description="low, medium, or high")
+    budget: Optional[float] = Field(None, description="Available budget in PKR")
+    land_size: Optional[float] = Field(None, description="Land size in acres")
+
+class MarketAdviceResponse(BaseModel):
+    crop: str
+    action: str  # SELL NOW, BUY INPUTS, HOLD, WAIT
+    current_price: float
+    price_trend: str
+    confidence: str
+    reasoning: str
+    risk_factors: List[str]
+    seasonal_context: str
+    timestamp: str
+    raw_advice: str
+
+class CropSummary(BaseModel):
+    crop: str
+    action: str
+    current_price: float
+    trend: str
+    confidence: str
+    quick_summary: str
+
+class MarketSummaryResponse(BaseModel):
+    timestamp: str
+    farmer_context: Optional[Dict[str, Any]] = None
+    crops: List[CropSummary]
+    market_overview: str
+    
+# -------------------- Historical Data Models --------------------
+class PricePoint(BaseModel):
+    timestamp: str
+    price: float
+    exchange_rate: Optional[float] = None
+
+class HistoricalData(BaseModel):
+    crop: str
+    period: str
+    data_points: List[PricePoint]
+    
+class MarketAnalytics(BaseModel):
+    crop: str
+    period: str
+    avg_price: float
+    min_price: float
+    max_price: float
+    volatility_index: float
+    trend_direction: str
+    confidence_score: float
+
+# -------------------- System Models --------------------
+class HealthStatus(BaseModel):
+    status: str
+    timestamp: str
+    services: Dict[str, str]
+    market_data_age: Optional[str] = None
+    historical_records: Optional[int] = None
+
+class InitializationResponse(BaseModel):
+    status: str
+    message: str
+    records_created: int
+    timestamp: str

requirements.txt

@@ -0,0 +1,9 @@
+fastapi
+python-dotenv
+httpx
+uvicorn
+bcrypt
+pydantic
+openai-agents
+requests
+firebase-admin

seed_market_data.py

@@ -0,0 +1,248 @@
+"""
+Seed 200 realistic market price entries into Firebase
+Run this once to populate your database with test data
+"""
+
+import random
+from datetime import datetime, timedelta
+from firebase_config import get_db_ref
+
+# Pakistan crop base prices (PKR per 40kg/maund)
+CROP_BASE_PRICES = {
+    "wheat": 3500,
+    "rice": 5200,
+    "maize": 2800,
+    "cotton": 8500,
+    "sugarcane": 350,
+    "potato": 2200,
+    "onion": 1800,
+    "tomato": 3200,
+}
+
+# Major markets across Pakistan
+MARKETS = {
+    "Sindh": ["Karachi", "Hyderabad", "Sukkur", "Larkana", "Mirpurkhas"],
+    "Punjab": ["Lahore", "Faisalabad", "Multan", "Rawalpindi", "Gujranwala"],
+    "Khyber Pakhtunkhwa": ["Peshawar", "Mardan", "Abbottabad", "Swat"],
+    "Balochistan": ["Quetta", "Khuzdar", "Turbat"]
+}
+
+# Regional price multipliers
+REGIONAL_MULTIPLIERS = {
+    "Sindh": 1.02,
+    "Punjab": 1.0,
+    "Khyber Pakhtunkhwa": 1.05,
+    "Balochistan": 1.08,
+}
+
+# Seasonal trends (monthly multipliers)
+SEASONAL_TRENDS = {
+    "wheat": {1: 1.05, 2: 1.08, 3: 1.10, 4: 0.95, 5: 0.92, 6: 0.95, 
+              7: 0.98, 8: 1.0, 9: 1.02, 10: 1.05, 11: 1.03, 12: 1.02},
+    "rice": {1: 1.02, 2: 1.0, 3: 0.98, 4: 0.96, 5: 0.95, 6: 0.98,
+             7: 1.0, 8: 1.05, 9: 1.08, 10: 0.95, 11: 0.92, 12: 0.98},
+    "cotton": {1: 1.0, 2: 0.98, 3: 0.96, 4: 0.95, 5: 1.0, 6: 1.05,
+               7: 1.08, 8: 1.10, 9: 0.95, 10: 0.90, 11: 0.92, 12: 0.95},
+}
+
+
+def generate_price_entry(crop, province, city, base_date, day_offset):
+    """Generate a single realistic price entry"""
+    
+    base_price = CROP_BASE_PRICES.get(crop, 3000)
+    regional_mult = REGIONAL_MULTIPLIERS.get(province, 1.0)
+    
+    # Calculate date
+    entry_date = base_date - timedelta(days=day_offset)
+    month = entry_date.month
+    
+    # Get seasonal multiplier
+    seasonal_mult = SEASONAL_TRENDS.get(crop, {}).get(month, 1.0)
+    
+    # Add realistic daily variation
+    daily_variation = random.uniform(-0.03, 0.03)  # ±3% daily
+    
+    # Add trend over time (slight price increase over 60 days)
+    trend_mult = 1 + (day_offset / 60) * 0.05  # 5% increase over period
+    
+    # Calculate final price
+    modal_price = base_price * regional_mult * seasonal_mult * (1 + daily_variation) * trend_mult
+    
+    # Generate min/max prices (±5% of modal)
+    min_price = modal_price * random.uniform(0.95, 0.98)
+    max_price = modal_price * random.uniform(1.02, 1.05)
+    
+    return {
+        "crop": crop,
+        "market": f"{city} Mandi",
+        "province": province,
+        "city": city,
+        "min_price": round(min_price, 2),
+        "max_price": round(max_price, 2),
+        "modal_price": round(modal_price, 2),
+        "currency": "PKR",
+        "unit": "40kg",
+        "timestamp": entry_date.isoformat(),
+        "date_key": entry_date.strftime("%Y-%m-%d"),
+        "source": "seeded"
+    }
+
+
+def seed_200_entries():
+    """Seed exactly 200 market price entries"""
+    
+    print("Starting to seed 200 market price entries...")
+    print("=" * 60)
+    
+    ref = get_db_ref("market_data/prices")
+    base_date = datetime.now()
+    
+    entries = []
+    
+    # Strategy: 200 entries over 60 days across different crops and markets
+    # 8 crops × 25 entries each = 200 total
+    
+    crops_to_seed = list(CROP_BASE_PRICES.keys())
+    entries_per_crop = 200 // len(crops_to_seed)  # 25 entries per crop
+    
+    entry_count = 0
+    
+    for crop in crops_to_seed:
+        print(f"\nSeeding {crop}...")
+        
+        # Distribute entries over 60 days
+        for i in range(entries_per_crop):
+            day_offset = (i * 60) // entries_per_crop  # Spread across 60 days
+            
+            # Rotate through provinces and cities
+            province = random.choice(list(MARKETS.keys()))
+            city = random.choice(MARKETS[province])
+            
+            entry = generate_price_entry(crop, province, city, base_date, day_offset)
+            
+            # Store in Firebase
+            # Path: market_data/prices/{crop}/{date_key}/{push_id}
+            date_key = entry["date_key"]
+            ref.child(f"{crop}/{date_key}").push(entry)
+            
+            entries.append(entry)
+            entry_count += 1
+            
+            if entry_count % 25 == 0:
+                print(f"  Progress: {entry_count}/200 entries created")
+    
+    print(f"\n{'=' * 60}")
+    print(f"✅ Successfully seeded {entry_count} market price entries!")
+    print(f"\nBreakdown:")
+    
+    # Show breakdown by crop
+    for crop in crops_to_seed:
+        crop_entries = [e for e in entries if e["crop"] == crop]
+        if crop_entries:
+            avg_price = sum(e["modal_price"] for e in crop_entries) / len(crop_entries)
+            print(f"  • {crop}: {len(crop_entries)} entries, avg price: ₨{avg_price:,.2f}")
+    
+    # Create latest prices snapshot
+    print("\nCreating latest prices snapshot...")
+    latest_prices = {}
+    for crop in crops_to_seed:
+        crop_entries = [e for e in entries if e["crop"] == crop]
+        if crop_entries:
+            latest = max(crop_entries, key=lambda x: x["timestamp"])
+            latest_prices[crop] = latest["modal_price"]
+    
+    latest_ref = get_db_ref("market_data/latest")
+    latest_ref.set({
+        "prices": latest_prices,
+        "timestamp": datetime.now().isoformat(),
+        "status": "seeded",
+        "source": "seed_script",
+        "total_crops": len(latest_prices)
+    })
+    
+    print("✅ Latest prices snapshot created")
+    
+    # Create metadata
+    metadata_ref = get_db_ref("market_data/metadata")
+    metadata_ref.set({
+        "total_entries": entry_count,
+        "crops": crops_to_seed,
+        "provinces": list(MARKETS.keys()),
+        "date_range": {
+            "start": (base_date - timedelta(days=60)).strftime("%Y-%m-%d"),
+            "end": base_date.strftime("%Y-%m-%d")
+        },
+        "last_seeded": datetime.now().isoformat(),
+        "currency": "PKR",
+        "unit": "40kg (Maund)"
+    })
+    
+    print("✅ Metadata created")
+    print(f"\n{'=' * 60}")
+    print("🎉 Database seeding complete!")
+    print("\nYou can now use the Market Agent to get advice based on this data.")
+    
+    return entries
+
+
+def verify_seeded_data():
+    """Verify that data was seeded correctly"""
+    print("\n" + "=" * 60)
+    print("Verifying seeded data...")
+    print("=" * 60)
+    
+    ref = get_db_ref("market_data/prices")
+    all_data = ref.get() or {}
+    
+    total_entries = 0
+    for crop, dates in all_data.items():
+        if isinstance(dates, dict):
+            for date, entries in dates.items():
+                if isinstance(entries, dict):
+                    total_entries += len(entries)
+    
+    print(f"\n📊 Total entries in database: {total_entries}")
+    
+    # Check latest prices
+    latest_ref = get_db_ref("market_data/latest")
+    latest = latest_ref.get()
+    
+    if latest:
+        print(f"\n💹 Latest prices available:")
+        for crop, price in latest.get("prices", {}).items():
+            print(f"  • {crop}: ₨{price:,.2f}")
+    
+    # Check metadata
+    metadata_ref = get_db_ref("market_data/metadata")
+    metadata = metadata_ref.get()
+    
+    if metadata:
+        print(f"\n📝 Metadata:")
+        print(f"  • Date range: {metadata.get('date_range', {}).get('start')} to {metadata.get('date_range', {}).get('end')}")
+        print(f"  • Crops: {len(metadata.get('crops', []))}")
+        print(f"  • Provinces: {len(metadata.get('provinces', []))}")
+    
+    print(f"\n{'=' * 60}")
+    
+    if total_entries >= 200:
+        print("✅ Verification PASSED - Database properly seeded!")
+    else:
+        print(f"⚠️  Warning: Expected 200+ entries, found {total_entries}")
+    
+    return total_entries
+
+
+if __name__ == "__main__":
+    try:
+        # Seed the data
+        entries = seed_200_entries()
+        
+        # Verify it worked
+        verify_seeded_data()
+        
+        print("\n✨ Run your Market Agent now to get advice!")
+        
+    except Exception as e:
+        print(f"\n❌ Error during seeding: {e}")
+        import traceback
+        traceback.print_exc()

soil_data_seeder.py

@@ -0,0 +1,225 @@
+"""
+Seed 200 realistic soil condition entries into Firebase
+Run this once to populate your database with test data for the Weather Agent
+"""
+
+import random
+from datetime import datetime, timedelta
+from firebase_config import get_db_ref
+
+# ------------------------------------------------------
+# 🌾 Base Soil Profiles (ideal conditions per crop)
+# ------------------------------------------------------
+SOIL_PROFILES = {
+    "wheat": {"moisture": (25, 35), "temp": (15, 25), "ph": (6.0, 7.5)},
+    "rice": {"moisture": (60, 80), "temp": (25, 35), "ph": (5.5, 6.5)},
+    "maize": {"moisture": (35, 50), "temp": (20, 30), "ph": (5.8, 7.0)},
+    "cotton": {"moisture": (30, 40), "temp": (22, 32), "ph": (6.0, 7.8)},
+    "sugarcane": {"moisture": (50, 70), "temp": (20, 30), "ph": (6.5, 7.5)},
+    "potato": {"moisture": (60, 75), "temp": (18, 25), "ph": (5.0, 6.0)},
+    "onion": {"moisture": (40, 60), "temp": (20, 30), "ph": (6.0, 7.0)},
+    "tomato": {"moisture": (50, 70), "temp": (20, 28), "ph": (5.5, 7.5)},
+}
+
+# ------------------------------------------------------
+# 🏞️ Major provinces and regions
+# ------------------------------------------------------
+REGIONS = {
+    "Sindh": ["Karachi", "Hyderabad", "Sukkur", "Larkana"],
+    "Punjab": ["Lahore", "Multan", "Faisalabad", "Rawalpindi"],
+    "Khyber Pakhtunkhwa": ["Peshawar", "Mardan", "Swat"],
+    "Balochistan": ["Quetta", "Khuzdar", "Turbat"],
+}
+
+# ------------------------------------------------------
+# 🌡️ Seasonal multipliers (approx. soil condition variations)
+# ------------------------------------------------------
+SEASONAL_EFFECTS = {
+    "winter": {"temp": 0.9, "moisture": 1.1},
+    "summer": {"temp": 1.1, "moisture": 0.9},
+    "monsoon": {"temp": 1.0, "moisture": 1.2},
+}
+
+# ------------------------------------------------------
+# 🧮 Generate a single soil record
+# ------------------------------------------------------
+def generate_soil_entry(crop, province, city, base_date, day_offset):
+    profile = SOIL_PROFILES[crop]
+    entry_date = base_date - timedelta(days=day_offset)
+    month = entry_date.month
+
+    # Determine season
+    if month in [12, 1, 2]:
+        season = "winter"
+    elif month in [6, 7, 8]:
+        season = "monsoon"
+    else:
+        season = "summer"
+
+    seasonal = SEASONAL_EFFECTS.get(season, {"temp": 1.0, "moisture": 1.0})
+
+    # Apply multipliers + random variation
+    soil_temp = random.uniform(*profile["temp"]) * random.uniform(0.95, 1.05) * seasonal["temp"]
+    soil_moisture = random.uniform(*profile["moisture"]) * random.uniform(0.9, 1.1) * seasonal["moisture"]
+    ph = random.uniform(*profile["ph"]) * random.uniform(0.98, 1.02)
+
+    return {
+        "crop": crop,
+        "province": province,
+        "city": city,
+        "region": f"{city}, {province}",
+        "soil_temperature": round(soil_temp, 2),
+        "soil_moisture": round(soil_moisture, 2),
+        "ph_level": round(ph, 2),
+        "nitrogen": random.randint(10, 60),
+        "phosphorus": random.randint(5, 40),
+        "potassium": random.randint(10, 50),
+        "rainfall_mm": round(random.uniform(0, 50), 2),
+        "season": season,
+        "timestamp": entry_date.isoformat(),
+        "date_key": entry_date.strftime("%Y-%m-%d"),
+        "source": "seeded"
+    }
+
+# ------------------------------------------------------
+# 🌱 Seed 200 soil entries into Firebase
+# ------------------------------------------------------
+def seed_200_soil_entries():
+    print("Starting to seed 200 soil condition entries...")
+    print("=" * 60)
+
+    ref = get_db_ref("soil_data/records")
+    base_date = datetime.now()
+    entries = []
+
+    crops_to_seed = list(SOIL_PROFILES.keys())
+    entries_per_crop = 200 // len(crops_to_seed)  # ~25 entries per crop
+    entry_count = 0
+
+    for crop in crops_to_seed:
+        print(f"\nSeeding soil data for {crop}...")
+
+        for i in range(entries_per_crop):
+            day_offset = (i * 60) // entries_per_crop
+            province = random.choice(list(REGIONS.keys()))
+            city = random.choice(REGIONS[province])
+
+            entry = generate_soil_entry(crop, province, city, base_date, day_offset)
+            date_key = entry["date_key"]
+            ref.child(f"{crop}/{date_key}").push(entry)
+
+            entries.append(entry)
+            entry_count += 1
+
+            if entry_count % 25 == 0:
+                print(f"  Progress: {entry_count}/200 entries created")
+
+    print(f"\n{'=' * 60}")
+    print(f"✅ Successfully seeded {entry_count} soil condition entries!")
+    create_summary(entries)
+    create_latest_snapshot(entries)
+    create_metadata(entries, crops_to_seed)
+    return entries
+
+# ------------------------------------------------------
+# 📊 Summary, Latest Snapshot & Metadata
+# ------------------------------------------------------
+def create_summary(entries):
+    summary_ref = get_db_ref("soil_data/summary")
+
+    avg_temp = sum(e["soil_temperature"] for e in entries) / len(entries)
+    avg_moisture = sum(e["soil_moisture"] for e in entries) / len(entries)
+    avg_ph = sum(e["ph_level"] for e in entries) / len(entries)
+
+    summary = {
+        "total_entries": len(entries),
+        "average_temp": round(avg_temp, 2),
+        "average_moisture": round(avg_moisture, 2),
+        "average_ph": round(avg_ph, 2),
+        "last_updated": datetime.now().isoformat()
+    }
+
+    summary_ref.set(summary)
+    print("✅ Soil data summary uploaded!")
+
+def create_latest_snapshot(entries):
+    latest_ref = get_db_ref("soil_data/latest")
+    latest_per_crop = {}
+
+    for crop in SOIL_PROFILES:
+        crop_entries = [e for e in entries if e["crop"] == crop]
+        if crop_entries:
+            latest = max(crop_entries, key=lambda x: x["timestamp"])
+            latest_per_crop[crop] = {
+                "soil_temperature": latest["soil_temperature"],
+                "soil_moisture": latest["soil_moisture"],
+                "ph_level": latest["ph_level"],
+                "region": latest["region"]
+            }
+
+    latest_ref.set({
+        "latest_conditions": latest_per_crop,
+        "timestamp": datetime.now().isoformat(),
+        "status": "seeded"
+    })
+    print("✅ Latest soil conditions snapshot created!")
+
+def create_metadata(entries, crops):
+    metadata_ref = get_db_ref("soil_data/metadata")
+    metadata_ref.set({
+        "total_entries": len(entries),
+        "crops": crops,
+        "provinces": list(REGIONS.keys()),
+        "date_range": {
+            "start": min(e["date_key"] for e in entries),
+            "end": max(e["date_key"] for e in entries)
+        },
+        "last_seeded": datetime.now().isoformat(),
+        "unit": "Soil metrics (%) / °C / pH"
+    })
+    print("✅ Metadata uploaded!")
+
+# ------------------------------------------------------
+# 🔍 Verification
+# ------------------------------------------------------
+def verify_soil_data():
+    print("\n" + "=" * 60)
+    print("Verifying seeded soil data...")
+    print("=" * 60)
+
+    ref = get_db_ref("soil_data/records")
+    all_data = ref.get() or {}
+    total_entries = 0
+
+    for crop, dates in all_data.items():
+        if isinstance(dates, dict):
+            for date, records in dates.items():
+                if isinstance(records, dict):
+                    total_entries += len(records)
+
+    print(f"\n📊 Total soil entries in database: {total_entries}")
+
+    summary_ref = get_db_ref("soil_data/summary")
+    summary = summary_ref.get()
+    if summary:
+        print(f"\n🌡️ Average Temp: {summary['average_temp']}°C | 💧 Moisture: {summary['average_moisture']}% | ⚗️ pH: {summary['average_ph']}")
+
+    if total_entries >= 200:
+        print("✅ Verification PASSED - Database properly seeded!")
+    else:
+        print(f"⚠️ Warning: Expected 200+ entries, found {total_entries}")
+
+    print(f"{'=' * 60}")
+
+# ------------------------------------------------------
+# 🚀 Main Run
+# ------------------------------------------------------
+if __name__ == "__main__":
+    try:
+        entries = seed_200_soil_entries()
+        verify_soil_data()
+        print("\n✨ Soil Data Seeder complete! You can now connect it to your Weather Agent.")
+    except Exception as e:
+        print(f"\n❌ Error during seeding: {e}")
+        import traceback
+        traceback.print_exc()