fix: re-adding local code files

README_ref.md

@@ -0,0 +1,213 @@
+# 🌾 Alert Summary Prototype Backend
+
+**Multi-stage MCP Pipeline for Agricultural Intelligence**
+
+---
+
+## 🎯 Overview
+
+Farmer.Chat uses a **4-stage pipeline** to process agricultural queries:
+
+```
+Query → Router → Executor (Parallel) → Compiler → Translator → Advice
+```
+
+### Architecture
+
+1. **Stage 1: Query Router** - Analyzes farmer's question and selects relevant MCP servers
+2. **Stage 2: MCP Executor** - Calls multiple APIs in parallel (weather, soil, water, elevation, pests)
+3. **Stage 3: Response Compiler** - Merges data from all sources
+4. **Stage 4: Farmer Translator** - Converts technical data to actionable farmer advice
+
+---
+
+## 🔌 API Endpoints
+
+### `POST /api/query`
+Process a farmer's question
+
+**Request:**
+```json
+{
+  "query": "Should I plant rice today?",
+  "location": {
+    "name": "Bangalore",
+    "lat": 12.8716,
+    "lon": 77.4946
+  }
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "query": "Should I plant rice today?",
+  "advice": "...",
+  "routing": {...},
+  "data": {...},
+  "execution_time_seconds": 3.5
+}
+```
+
+### `POST /api/export-pdf`
+Export query result as PDF
+
+**Request:** Same as `/api/query`
+
+**Response:** PDF file download
+
+### `GET /api/health`
+Health check
+
+### `GET /api/servers`
+List available MCP servers
+
+---
+
+## 🛠️ MCP Servers
+
+| Server | Data Source | Information |
+|--------|-------------|-------------|
+| **weather** | Open-Meteo | Current weather, 7-day forecasts |
+| **soil_properties** | SoilGrids | Clay, sand, pH, nutrients |
+| **water** | GRACE Satellite | Groundwater levels, drought status |
+| **elevation** | OpenElevation | Field elevation, terrain data |
+| **pests** | iNaturalist | Recent pest observations |
+
+---
+
+## 🚀 Deployment Instructions
+
+### 1. Create Hugging Face Space
+
+1. Go to https://huggingface.co/new-space
+2. Space name: `farmer-chat-backend`
+3. Owner: `aakashdg`
+4. SDK: **Gradio** (we'll use FastAPI inside)
+5. Set to **Public**
+
+### 2. Upload Files
+
+Upload all files maintaining this structure:
+```
+farmer-chat-backend/
+├── app.py
+├── requirements.txt
+├── README.md
+├── src/
+│   ├── __init__.py
+│   ├── pipeline.py
+│   ├── router.py
+│   ├── executor.py
+│   ├── compiler.py
+│   ├── translator.py
+│   ├── pdf_generator.py
+│   └── servers/
+│       ├── __init__.py
+│       └── (all server classes in one file or separate)
+```
+
+### 3. Set Environment Variables
+
+In Space Settings → Variables and secrets:
+- Add secret: `OPENAI_API_KEY` = your OpenAI API key
+
+### 4. Deploy!
+
+Space will auto-deploy. Access at:
+```
+https://huggingface.co/spaces/aakashdg/farmer-chat-backend
+```
+
+---
+
+## 🧪 Testing
+
+### Test with cURL:
+
+```bash
+curl -X POST https://huggingface.co/spaces/aakashdg/farmer-chat-backend/api/query \
+  -H "Content-Type: application/json" \
+  -d '{
+    "query": "What is the soil composition?",
+    "location": {"name": "Bangalore", "lat": 12.8716, "lon": 77.4946}
+  }'
+```
+
+### Test with Python:
+
+```python
+import requests
+
+response = requests.post(
+    "https://huggingface.co/spaces/aakashdg/farmer-chat-backend/api/query",
+    json={
+        "query": "Will it rain this week?",
+        "location": {"name": "Bangalore", "lat": 12.8716, "lon": 77.4946}
+    }
+)
+
+print(response.json())
+```
+
+---
+
+## 📊 Performance
+
+- **Parallel execution**: All MCP servers called simultaneously
+- **Typical response time**: 3-5 seconds
+- **Success rate**: ~95% (graceful degradation if servers fail)
+
+---
+
+## 🔐 Security
+
+- OpenAI API key stored as HF Space secret
+- CORS enabled for frontend integration
+- Rate limiting: 100 queries/hour per IP (configurable)
+
+---
+
+## 📈 Scaling
+
+To add more MCP servers:
+
+1. Create new server class in `src/servers/`
+2. Add to `MCP_SERVER_REGISTRY` in `executor.py`
+3. Router will automatically include it in routing decisions
+
+---
+
+## 🐛 Troubleshooting
+
+### "OPENAI_API_KEY not set"
+- Check HF Space Settings → Variables and secrets
+- Ensure secret name is exactly `OPENAI_API_KEY`
+
+### Slow responses
+- Normal for first query (cold start)
+- Subsequent queries faster due to caching
+
+### Server failures
+- System uses graceful degradation
+- If one server fails, others still provide data
+- Check `failed_servers` in response
+
+---
+
+## 📞 Support
+
+- GitHub Issues: [Link to repo]
+- Creator: @aakashdg
+- Built for: Farmer.chat product demo
+
+---
+
+## 📄 License
+
+MIT License
+
+---
+
+**Built with ❤️ for farmers**

app.py

@@ -0,0 +1,1247 @@
+# # """
+# # Farmer.Chat Backend - FastAPI Application
+# # Deploy to Hugging Face Space: https://huggingface.co/spaces/aakashdg/farmer-chat-backend
+# # """
+
+# # from fastapi import FastAPI, HTTPException
+# # from fastapi.middleware.cors import CORSMiddleware
+# # from fastapi.responses import FileResponse, JSONResponse
+# # from pydantic import BaseModel, Field
+# # from typing import Optional, Dict, Any
+# # import os
+# # import asyncio
+# # import time
+# # from datetime import datetime
+
+# # # Import pipeline components
+# # from src.pipeline import FarmerChatPipeline
+# # from src.pdf_generator import generate_pdf_report
+
+# # from openai import OpenAI
+# # import httpx
+
+# # # Initialize FastAPI
+# # app = FastAPI(
+# #     title="Farmer.Chat Backend",
+# #     description="Multi-stage MCP pipeline for agricultural intelligence",
+# #     version="2.0.0"
+# # )
+
+# # # CORS - Allow all origins for demo (restrict in production)
+# # app.add_middleware(
+# #     CORSMiddleware,
+# #     allow_origins=["*"],
+# #     allow_credentials=True,
+# #     allow_methods=["*"],
+# #     allow_headers=["*"],
+# # )
+
+# # # Initialize OpenAI client with FIXED httpx configuration
+# # OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+# # if not OPENAI_API_KEY:
+# #     raise ValueError("OPENAI_API_KEY environment variable not set!")
+
+# # # FIX: Create httpx client without proxy support
+# # http_client = httpx.Client(
+# #     timeout=httpx.Timeout(60.0),
+# #     limits=httpx.Limits(max_keepalive_connections=5, max_connections=10)
+# # )
+
+# # # Initialize OpenAI with custom http client (bypasses proxy issues)
+# # openai_client = OpenAI(
+# #     api_key=OPENAI_API_KEY,
+# #     http_client=http_client
+# # )
+
+# # print("✅ OpenAI client initialized with custom httpx client")
+# # print(f"   Model: gpt-4o")
+
+# # # Default location (Bangalore Agricultural Region)
+# # DEFAULT_LOCATION = {
+# #     "name": "Bangalore Agricultural Region",
+# #     "lat": 12.8716,
+# #     "lon": 77.4946
+# # }
+
+# # # Initialize pipeline
+# # pipeline = FarmerChatPipeline(openai_client, DEFAULT_LOCATION)
+
+# # # Request/Response Models
+# # class QueryRequest(BaseModel):
+# #     query: str = Field(..., min_length=3, max_length=500, description="Farmer's question")
+# #     location: Optional[Dict[str, Any]] = Field(None, description="Custom location (lat, lon, name)")
+    
+# #     class Config:
+# #         json_schema_extra = {
+# #             "example": {
+# #                 "query": "Should I plant rice today?",
+# #                 "location": {
+# #                     "name": "Bangalore",
+# #                     "lat": 12.8716,
+# #                     "lon": 77.4946
+# #                 }
+# #             }
+# #         }
+
+
+# # class QueryResponse(BaseModel):
+# #     success: bool
+# #     query: str
+# #     advice: str
+# #     routing: Dict[str, Any]
+# #     data: Dict[str, Any]
+# #     execution_time_seconds: float
+# #     timestamp: str
+
+
+# # # Health check
+# # @app.get("/")
+# # async def root():
+# #     return {
+# #         "service": "Farmer.Chat Backend",
+# #         "status": "operational",
+# #         "version": "2.0.0",
+# #         "endpoints": {
+# #             "query": "/api/query",
+# #             "health": "/api/health",
+# #             "servers": "/api/servers"
+# #         }
+# #     }
+
+
+# # @app.get("/api/health")
+# # async def health_check():
+# #     """Health check endpoint"""
+# #     return {
+# #         "status": "healthy",
+# #         "timestamp": datetime.now().isoformat(),
+# #         "openai_configured": bool(OPENAI_API_KEY),
+# #         "location": DEFAULT_LOCATION
+# #     }
+
+
+# # @app.get("/api/servers")
+# # async def list_servers():
+# #     """List available MCP servers"""
+# #     from src.executor import MCP_SERVER_REGISTRY
+    
+# #     return {
+# #         "total_servers": len(MCP_SERVER_REGISTRY),
+# #         "servers": MCP_SERVER_REGISTRY
+# #     }
+
+
+# # @app.post("/api/query", response_model=QueryResponse)
+# # async def process_query(request: QueryRequest):
+# #     """
+# #     Main query endpoint - processes farmer questions through MCP pipeline
+# #     """
+# #     try:
+# #         start_time = time.time()
+        
+# #         # Use custom location if provided, otherwise default
+# #         location = request.location if request.location else DEFAULT_LOCATION
+        
+# #         # Update pipeline location if changed
+# #         if request.location:
+# #             pipeline.location = location
+        
+# #         # Process query through pipeline
+# #         result = await pipeline.process_query(request.query, verbose=False)
+        
+# #         execution_time = time.time() - start_time
+        
+# #         return QueryResponse(
+# #             success=True,
+# #             query=request.query,
+# #             advice=result["advice"],
+# #             routing=result["routing"],
+# #             data=result["compiled_data"],
+# #             execution_time_seconds=round(execution_time, 2),
+# #             timestamp=datetime.now().isoformat()
+# #         )
+        
+# #     except Exception as e:
+# #         raise HTTPException(status_code=500, detail=str(e))
+
+
+# # @app.post("/api/export-pdf")
+# # async def export_pdf(request: QueryRequest):
+# #     """
+# #     Export query result as PDF
+# #     """
+# #     try:
+# #         # Process query
+# #         result = await pipeline.process_query(request.query, verbose=False)
+        
+# #         # Generate PDF
+# #         pdf_path = generate_pdf_report(
+# #             query=request.query,
+# #             advice=result["advice"],
+# #             data=result["compiled_data"],
+# #             location=pipeline.location
+# #         )
+        
+# #         # Return PDF file
+# #         return FileResponse(
+# #             pdf_path,
+# #             media_type="application/pdf",
+# #             filename=f"farmer-chat-report-{int(time.time())}.pdf"
+# #         )
+        
+# #     except Exception as e:
+# #         raise HTTPException(status_code=500, detail=str(e))
+
+
+# # # Error handlers
+# # @app.exception_handler(404)
+# # async def not_found_handler(request, exc):
+# #     return JSONResponse(
+# #         status_code=404,
+# #         content={"error": "Endpoint not found", "path": str(request.url)}
+# #     )
+
+
+# # @app.exception_handler(500)
+# # async def server_error_handler(request, exc):
+# #     return JSONResponse(
+# #         status_code=500,
+# #         content={"error": "Internal server error", "detail": str(exc)}
+# #     )
+
+
+# # if __name__ == "__main__":
+# #     import uvicorn
+# #     uvicorn.run(app, host="0.0.0.0", port=7860)
+
+# """
+# Alert Summary Generator Backend - Standalone Version
+# FastAPI app with embedded pipeline and location data
+# """
+
+# from fastapi import FastAPI, HTTPException
+# from fastapi.middleware.cors import CORSMiddleware
+# from pydantic import BaseModel
+# from typing import Optional, Dict, Any, List
+# import os
+# from datetime import datetime
+# from openai import OpenAI
+# import httpx
+
+# # ============================================================================
+# # OPENAI CLIENT SETUP
+# # ============================================================================
+
+# def get_openai_client():
+#     """Initialize OpenAI client with API key from environment"""
+#     api_key = os.getenv("OPENAI_API_KEY")
+#     if not api_key:
+#         raise ValueError("OPENAI_API_KEY environment variable not set")
+#     http_client = httpx.Client(
+#         timeout=httpx.Timeout(60.0, connect=10.0),
+#         limits=httpx.Limits(max_keepalive_connections=10, max_connections=20)
+#     )
+#     return OpenAI(api_key=api_key, http_client=http_client)
+
+
+# # ============================================================================
+# # PIPELINE COMPONENTS
+# # ============================================================================
+
+# class QueryRouter:
+#     """Routes queries to appropriate MCP servers"""
+    
+#     def __init__(self, client):
+#         self.client = client
+    
+#     def route_query(self, query: str, location: Dict[str, float]) -> Dict[str, Any]:
+#         """Determine which servers to call based on query"""
+#         prompt = f"""Given the farmer query: "{query}"
+# Location: {location['latitude']}, {location['longitude']}
+
+# Determine which data sources are needed. Return JSON:
+# {{
+#     "weather": true/false,
+#     "soil": true/false, 
+#     "water": true/false,
+#     "elevation": true/false,
+#     "pests": true/false
+# }}"""
+        
+#         response = self.client.chat.completions.create(
+#             model="gpt-4",
+#             messages=[{"role": "user", "content": prompt}],
+#             temperature=0
+#         )
+        
+#         # Parse routing decision
+#         import json
+#         try:
+#             routing = json.loads(response.choices[0].message.content)
+#         except:
+#             # Default: query all servers for alerts
+#             routing = {
+#                 "weather": True,
+#                 "soil": True,
+#                 "water": True,
+#                 "elevation": True,
+#                 "pests": True
+#             }
+        
+#         return routing
+
+
+# class MCPExecutor:
+#     """Executes parallel calls to MCP servers"""
+    
+#     def __init__(self, client):
+#         self.client = client
+    
+#     def execute_parallel(self, routing: Dict[str, bool], location: Dict[str, float]) -> Dict[str, str]:
+#         """Execute MCP server calls in parallel"""
+#         results = {}
+        
+#         # Simulate MCP server calls (replace with actual server calls)
+#         if routing.get("weather"):
+#             results["weather"] = f"Weather data for {location['latitude']}, {location['longitude']}"
+        
+#         if routing.get("soil"):
+#             results["soil"] = f"Soil data for {location['latitude']}, {location['longitude']}"
+        
+#         if routing.get("water"):
+#             results["water"] = f"Water availability for {location['latitude']}, {location['longitude']}"
+        
+#         if routing.get("elevation"):
+#             results["elevation"] = f"Elevation data for {location['latitude']}, {location['longitude']}"
+        
+#         if routing.get("pests"):
+#             results["pests"] = f"Pest risk data for {location['latitude']}, {location['longitude']}"
+        
+#         return results
+
+
+# class ResponseCompiler:
+#     """Compiles MCP results into coherent response"""
+    
+#     def __init__(self, client):
+#         self.client = client
+    
+#     def compile_response(self, query: str, mcp_results: Dict[str, str], location: Dict[str, float]) -> str:
+#         """Compile MCP results into final response"""
+        
+#         # Format MCP results for context
+#         context = "\n\n".join([f"{k.upper()}: {v}" for k, v in mcp_results.items()])
+        
+#         prompt = f"""You are an agricultural assistant. Compile this data into a comprehensive alert summary.
+
+# FARMER QUERY: {query}
+# LOCATION: {location['latitude']}, {location['longitude']}
+
+# DATA FROM SOURCES:
+# {context}
+
+# Provide a comprehensive agricultural alert covering:
+# 1. Current weather conditions and forecast
+# 2. Soil health and recommendations  
+# 3. Water availability status
+# 4. Elevation/topography considerations
+# 5. Pest risks and preventive measures
+
+# Be specific, actionable, and farmer-friendly."""
+
+#         response = self.client.chat.completions.create(
+#             model="gpt-4",
+#             messages=[{"role": "user", "content": prompt}],
+#             temperature=0.7
+#         )
+        
+#         return response.choices[0].message.content
+
+
+# class HindiTranslator:
+#     """Translates responses to Hindi"""
+    
+#     def __init__(self, client):
+#         self.client = client
+    
+#     def translate(self, text: str, target_lang: str = "en") -> str:
+#         """Translate text if needed"""
+#         if target_lang == "en":
+#             return text
+        
+#         # Add Hindi translation logic here
+#         return text
+
+
+# class FarmerChatPipeline:
+#     """Main pipeline orchestrating all stages"""
+    
+#     def __init__(self, client, location: Dict[str, float]):
+#         self.client = client
+#         self.location = location
+#         self.router = QueryRouter(client)
+#         self.executor = MCPExecutor(client)
+#         self.compiler = ResponseCompiler(client)
+#         self.translator = HindiTranslator(client)
+    
+#     def process_query(self, query: str, language: str = "en") -> str:
+#         """Process query through full pipeline"""
+        
+#         # Stage 1: Route query
+#         routing = self.router.route_query(query, self.location)
+        
+#         # Stage 2: Execute MCP calls
+#         mcp_results = self.executor.execute_parallel(routing, self.location)
+        
+#         # Stage 3: Compile response
+#         response = self.compiler.compile_response(query, mcp_results, self.location)
+        
+#         # Stage 4: Translate if needed
+#         final_response = self.translator.translate(response, language)
+        
+#         return final_response
+
+
+# # ============================================================================
+# # BIHAR LOCATION DATA
+# # ============================================================================
+
+# BIHAR_DATA = {
+#     "Araria": ["Araria", "Forbesganj", "Jokihat", "Raniganj"],
+#     "Arwal": ["Arwal", "Kaler", "Karpi", "Kurtha"],
+#     "Aurangabad": ["Aurangabad", "Daudnagar", "Obra", "Nabinagar"],
+#     "Banka": ["Banka", "Amarpur", "Barahat", "Belhar"],
+#     "Begusarai": ["Begusarai", "Bakhri", "Barauni", "Teghra"],
+#     "Bhagalpur": ["Bhagalpur", "Sabour", "Nathnagar", "Kahalgaon"],
+#     "Bhojpur": ["Arrah", "Jagdishpur", "Piro", "Shahpur"],
+#     "Buxar": ["Buxar", "Dumraon", "Chausa", "Simri"],
+#     "Darbhanga": ["Darbhanga", "Baheri", "Jale", "Benipur"],
+#     "East Champaran": ["Motihari", "Raxaul", "Chakia", "Dhaka"],
+#     "Gaya": ["Gaya", "Bodh Gaya", "Tekari", "Sherghati"],
+#     "Gopalganj": ["Gopalganj", "Barauli", "Baikunthpur", "Kateya"],
+#     "Jamui": ["Jamui", "Jhajha", "Sikandra", "Sono"],
+#     "Jehanabad": ["Jehanabad", "Ghoshi", "Makhdumpur", "Modanganj"],
+#     "Kaimur": ["Bhabua", "Mohania", "Ramgarh", "Chainpur"],
+#     "Katihar": ["Katihar", "Barsoi", "Manihari", "Pranpur"],
+#     "Khagaria": ["Khagaria", "Parbatta", "Alauli", "Beldaur"],
+#     "Kishanganj": ["Kishanganj", "Bahadurganj", "Thakurganj", "Dighalbank"],
+#     "Lakhisarai": ["Lakhisarai", "Halsi", "Suryagarha", "Pipariya"],
+#     "Madhepura": ["Madhepura", "Udakishanganj", "Murliganj", "Alamnagar"],
+#     "Madhubani": ["Madhubani", "Jhanjharpur", "Benipatti", "Jainagar"],
+#     "Munger": ["Munger", "Jamalpur", "Asarganj", "Tarapur"],
+#     "Muzaffarpur": ["Muzaffarpur", "Sitamarhi", "Minapur", "Bochaha"],
+#     "Nalanda": ["Bihar Sharif", "Rajgir", "Hilsa", "Biharsharif"],
+#     "Nawada": ["Nawada", "Rajauli", "Akbarpur", "Hisua"],
+#     "Patna": ["Patna", "Danapur", "Fatuha", "Khagaul"],
+#     "Purnia": ["Purnia", "Dhamdaha", "Kasba", "Banmankhi"],
+#     "Rohtas": ["Sasaram", "Dehri", "Bikramganj", "Nasriganj"],
+#     "Saharsa": ["Saharsa", "Sonbarsa", "Simri Bakhtiarpur", "Mahishi"],
+#     "Samastipur": ["Samastipur", "Rosera", "Dalsinghsarai", "Pusa"],
+#     "Saran": ["Chapra", "Marhaura", "Amnour", "Sonepur"],
+#     "Sheikhpura": ["Sheikhpura", "Barbigha", "Ariari", "Shekhopur"],
+#     "Sheohar": ["Sheohar", "Dumri Katsari", "Piprahi", "Tariyani"],
+#     "Sitamarhi": ["Sitamarhi", "Pupri", "Belsand", "Bathnaha"],
+#     "Siwan": ["Siwan", "Maharajganj", "Mairwa", "Darauli"],
+#     "Supaul": ["Supaul", "Nirmali", "Triveniganj", "Chhatapur"],
+#     "Vaishali": ["Hajipur", "Mahua", "Lalganj", "Desri"],
+#     "West Champaran": ["Bettiah", "Bagaha", "Narkatiaganj", "Lauriya"]
+# }
+
+# LOCATIONS = {
+#     "Araria": {"latitude": 26.1523, "longitude": 87.5167},
+#     "Forbesganj": {"latitude": 26.3023, "longitude": 87.2664},
+#     "Jokihat": {"latitude": 25.8998, "longitude": 87.2686},
+#     "Raniganj": {"latitude": 26.0537, "longitude": 87.5333},
+#     "Arwal": {"latitude": 25.2560, "longitude": 84.6819},
+#     "Kaler": {"latitude": 25.1960, "longitude": 84.6219},
+#     "Karpi": {"latitude": 25.2360, "longitude": 84.7019},
+#     "Kurtha": {"latitude": 25.3160, "longitude": 84.6619},
+#     "Aurangabad": {"latitude": 24.7521, "longitude": 84.3742},
+#     "Daudnagar": {"latitude": 25.0337, "longitude": 84.4007},
+#     "Obra": {"latitude": 24.9923, "longitude": 84.4342},
+#     "Nabinagar": {"latitude": 24.6087, "longitude": 84.1269},
+#     "Banka": {"latitude": 24.8893, "longitude": 86.9220},
+#     "Amarpur": {"latitude": 25.0393, "longitude": 86.9020},
+#     "Barahat": {"latitude": 24.8393, "longitude": 87.0020},
+#     "Belhar": {"latitude": 24.9393, "longitude": 86.9620},
+#     "Begusarai": {"latitude": 25.4182, "longitude": 86.1347},
+#     "Bakhri": {"latitude": 25.4582, "longitude": 86.0547},
+#     "Barauni": {"latitude": 25.4751, "longitude": 86.0458},
+#     "Teghra": {"latitude": 25.5082, "longitude": 85.9347},
+#     "Bhagalpur": {"latitude": 25.2425, "longitude": 86.9842},
+#     "Sabour": {"latitude": 25.2375, "longitude": 87.0542},
+#     "Nathnagar": {"latitude": 25.1225, "longitude": 87.0042},
+#     "Kahalgaon": {"latitude": 25.1925, "longitude": 87.2142},
+#     "Arrah": {"latitude": 25.5560, "longitude": 84.6631},
+#     "Jagdishpur": {"latitude": 25.4660, "longitude": 84.4231},
+#     "Piro": {"latitude": 25.3260, "longitude": 84.4031},
+#     "Shahpur": {"latitude": 25.6060, "longitude": 84.4031},
+#     "Buxar": {"latitude": 25.5641, "longitude": 83.9778},
+#     "Dumraon": {"latitude": 25.5541, "longitude": 84.1478},
+#     "Chausa": {"latitude": 25.5241, "longitude": 83.9178},
+#     "Simri": {"latitude": 25.6141, "longitude": 84.0478},
+#     "Darbhanga": {"latitude": 26.1542, "longitude": 85.8978},
+#     "Baheri": {"latitude": 26.0442, "longitude": 85.8378},
+#     "Jale": {"latitude": 26.2042, "longitude": 85.8578},
+#     "Benipur": {"latitude": 26.1142, "longitude": 85.9478},
+#     "Motihari": {"latitude": 26.6484, "longitude": 84.9194},
+#     "Raxaul": {"latitude": 26.9784, "longitude": 84.8494},
+#     "Chakia": {"latitude": 26.4184, "longitude": 85.0494},
+#     "Dhaka": {"latitude": 26.6784, "longitude": 85.1694},
+#     "Gaya": {"latitude": 24.7955, "longitude": 85.0002},
+#     "Bodh Gaya": {"latitude": 24.6955, "longitude": 84.9902},
+#     "Tekari": {"latitude": 24.9455, "longitude": 85.0402},
+#     "Sherghati": {"latitude": 24.5655, "longitude": 84.7902},
+#     "Gopalganj": {"latitude": 26.4685, "longitude": 84.4388},
+#     "Barauli": {"latitude": 26.3785, "longitude": 84.5788},
+#     "Baikunthpur": {"latitude": 26.5285, "longitude": 84.3588},
+#     "Kateya": {"latitude": 26.4285, "longitude": 84.6388},
+#     "Jamui": {"latitude": 24.9272, "longitude": 86.2231},
+#     "Jhajha": {"latitude": 24.7772, "longitude": 86.3731},
+#     "Sikandra": {"latitude": 24.9672, "longitude": 86.0631},
+#     "Sono": {"latitude": 24.8372, "longitude": 86.1431},
+#     "Jehanabad": {"latitude": 25.2078, "longitude": 84.9869},
+#     "Ghoshi": {"latitude": 25.1478, "longitude": 84.9269},
+#     "Makhdumpur": {"latitude": 25.2478, "longitude": 85.0469},
+#     "Modanganj": {"latitude": 25.2678, "longitude": 84.9069},
+#     "Bhabua": {"latitude": 25.0405, "longitude": 83.6074},
+#     "Mohania": {"latitude": 25.1305, "longitude": 83.4774},
+#     "Ramgarh": {"latitude": 24.9505, "longitude": 83.6874},
+#     "Chainpur": {"latitude": 25.2005, "longitude": 83.7474},
+#     "Katihar": {"latitude": 25.5394, "longitude": 87.5839},
+#     "Barsoi": {"latitude": 25.3794, "longitude": 87.8839},
+#     "Manihari": {"latitude": 25.3394, "longitude": 87.6239},
+#     "Pranpur": {"latitude": 25.6894, "longitude": 87.7239},
+#     "Khagaria": {"latitude": 25.5022, "longitude": 86.4665},
+#     "Parbatta": {"latitude": 25.5422, "longitude": 86.5865},
+#     "Alauli": {"latitude": 25.4622, "longitude": 86.3465},
+#     "Beldaur": {"latitude": 25.5622, "longitude": 86.4265},
+#     "Kishanganj": {"latitude": 26.1046, "longitude": 87.9475},
+#     "Bahadurganj": {"latitude": 26.2646, "longitude": 88.1175},
+#     "Thakurganj": {"latitude": 26.0446, "longitude": 87.8275},
+#     "Dighalbank": {"latitude": 25.9046, "longitude": 87.9875},
+#     "Lakhisarai": {"latitude": 25.1678, "longitude": 86.0927},
+#     "Halsi": {"latitude": 25.2278, "longitude": 86.0327},
+#     "Suryagarha": {"latitude": 25.1078, "longitude": 86.1527},
+#     "Pipariya": {"latitude": 25.2078, "longitude": 86.1327},
+#     "Madhepura": {"latitude": 25.9207, "longitude": 86.7940},
+#     "Udakishanganj": {"latitude": 25.9807, "longitude": 86.6740},
+#     "Murliganj": {"latitude": 25.8907, "longitude": 86.9940},
+#     "Alamnagar": {"latitude": 25.9607, "longitude": 86.7340},
+#     "Madhubani": {"latitude": 26.3561, "longitude": 86.0644},
+#     "Jhanjharpur": {"latitude": 26.2661, "longitude": 86.2844},
+#     "Benipatti": {"latitude": 26.5961, "longitude": 86.1444},
+#     "Jainagar": {"latitude": 26.2061, "longitude": 86.1644},
+#     "Munger": {"latitude": 25.3753, "longitude": 86.4734},
+#     "Jamalpur": {"latitude": 25.3153, "longitude": 86.4934},
+#     "Asarganj": {"latitude": 25.1453, "longitude": 86.6834},
+#     "Tarapur": {"latitude": 25.0253, "longitude": 86.6334},
+#     "Muzaffarpur": {"latitude": 26.1225, "longitude": 85.3906},
+#     "Sitamarhi": {"latitude": 26.5925, "longitude": 85.4806},
+#     "Minapur": {"latitude": 26.0625, "longitude": 85.2906},
+#     "Bochaha": {"latitude": 26.0025, "longitude": 85.5306},
+#     "Bihar Sharif": {"latitude": 25.1979, "longitude": 85.5238},
+#     "Rajgir": {"latitude": 25.0279, "longitude": 85.4238},
+#     "Hilsa": {"latitude": 25.3179, "longitude": 85.2838},
+#     "Biharsharif": {"latitude": 25.1979, "longitude": 85.5238},
+#     "Nawada": {"latitude": 24.8834, "longitude": 85.5387},
+#     "Rajauli": {"latitude": 25.0634, "longitude": 85.6387},
+#     "Akbarpur": {"latitude": 24.8234, "longitude": 85.4587},
+#     "Hisua": {"latitude": 24.8334, "longitude": 85.4187},
+#     "Patna": {"latitude": 25.5941, "longitude": 85.1376},
+#     "Danapur": {"latitude": 25.6341, "longitude": 85.0476},
+#     "Fatuha": {"latitude": 25.5041, "longitude": 85.3076},
+#     "Khagaul": {"latitude": 25.5741, "longitude": 85.0476},
+#     "Purnia": {"latitude": 25.7771, "longitude": 87.4753},
+#     "Dhamdaha": {"latitude": 25.8871, "longitude": 87.5853},
+#     "Kasba": {"latitude": 25.8471, "longitude": 87.5353},
+#     "Banmankhi": {"latitude": 25.8871, "longitude": 87.1953},
+#     "Sasaram": {"latitude": 24.9520, "longitude": 84.0328},
+#     "Dehri": {"latitude": 24.9020, "longitude": 84.1828},
+#     "Bikramganj": {"latitude": 25.2120, "longitude": 84.2628},
+#     "Nasriganj": {"latitude": 25.0520, "longitude": 84.1228},
+#     "Saharsa": {"latitude": 25.8769, "longitude": 86.5956},
+#     "Sonbarsa": {"latitude": 25.9269, "longitude": 86.7356},
+#     "Simri Bakhtiarpur": {"latitude": 25.9569, "longitude": 86.3556},
+#     "Mahishi": {"latitude": 25.9969, "longitude": 86.4756},
+#     "Samastipur": {"latitude": 25.8647, "longitude": 85.7817},
+#     "Rosera": {"latitude": 25.7947, "longitude": 85.9317},
+#     "Dalsinghsarai": {"latitude": 25.6647, "longitude": 85.8317},
+#     "Pusa": {"latitude": 25.9847, "longitude": 85.6717},
+#     "Chapra": {"latitude": 25.7805, "longitude": 84.7477},
+#     "Marhaura": {"latitude": 25.9705, "longitude": 84.8677},
+#     "Amnour": {"latitude": 25.8905, "longitude": 84.9077},
+#     "Sonepur": {"latitude": 25.6905, "longitude": 85.1777},
+#     "Sheikhpura": {"latitude": 25.1391, "longitude": 85.8354},
+#     "Barbigha": {"latitude": 25.2191, "longitude": 85.7354},
+#     "Ariari": {"latitude": 25.0591, "longitude": 85.9554},
+#     "Shekhopur": {"latitude": 25.1391, "longitude": 85.8354},
+#     "Sheohar": {"latitude": 26.5184, "longitude": 85.2959},
+#     "Dumri Katsari": {"latitude": 26.5784, "longitude": 85.1959},
+#     "Piprahi": {"latitude": 26.4684, "longitude": 85.4159},
+#     "Tariyani": {"latitude": 26.5584, "longitude": 85.2359},
+#     "Sitamarhi": {"latitude": 26.5925, "longitude": 85.4806},
+#     "Pupri": {"latitude": 26.4725, "longitude": 85.7006},
+#     "Belsand": {"latitude": 26.4425, "longitude": 85.4006},
+#     "Bathnaha": {"latitude": 26.5925, "longitude": 85.5306},
+#     "Siwan": {"latitude": 26.2195, "longitude": 84.3564},
+#     "Maharajganj": {"latitude": 26.1095, "longitude": 84.5064},
+#     "Mairwa": {"latitude": 26.2295, "longitude": 84.1664},
+#     "Darauli": {"latitude": 26.1595, "longitude": 84.1464},
+#     "Supaul": {"latitude": 26.1260, "longitude": 86.6050},
+#     "Nirmali": {"latitude": 26.3160, "longitude": 86.5850},
+#     "Triveniganj": {"latitude": 26.2160, "longitude": 87.0250},
+#     "Chhatapur": {"latitude": 26.2160, "longitude": 86.9050},
+#     "Hajipur": {"latitude": 25.6851, "longitude": 85.2095},
+#     "Mahua": {"latitude": 25.9651, "longitude": 85.2895},
+#     "Lalganj": {"latitude": 25.8751, "longitude": 85.1695},
+#     "Desri": {"latitude": 25.6051, "longitude": 85.4895},
+#     "Bettiah": {"latitude": 26.8022, "longitude": 84.5025},
+#     "Bagaha": {"latitude": 27.0922, "longitude": 84.0925},
+#     "Narkatiaganj": {"latitude": 26.4322, "longitude": 84.7925},
+#     "Lauriya": {"latitude": 26.9822, "longitude": 84.3125}
+# }
+
+
+# # ============================================================================
+# # FASTAPI APP
+# # ============================================================================
+
+# app = FastAPI(title="Farmer.chat Alert Summary API")
+
+# # CORS middleware
+# app.add_middleware(
+#     CORSMiddleware,
+#     allow_origins=["*"],
+#     allow_credentials=True,
+#     allow_methods=["*"],
+#     allow_headers=["*"],
+# )
+
+# # Initialize pipeline
+# openai_client = None
+# pipeline = None
+
+# @app.on_event("startup")
+# async def startup_event():
+#     """Initialize OpenAI client and pipeline on startup"""
+#     global openai_client, pipeline
+#     try:
+#         openai_client = get_openai_client()
+#         DEFAULT_LOCATION = {"latitude": 25.5941, "longitude": 85.1376}
+#         pipeline = FarmerChatPipeline(openai_client, DEFAULT_LOCATION)
+#         print("✓ Pipeline initialized successfully")
+#     except Exception as e:
+#         print(f"✗ Pipeline initialization failed: {e}")
+#         raise
+
+
+# # ============================================================================
+# # API MODELS
+# # ============================================================================
+
+# class LocationRequest(BaseModel):
+#     location_name: str
+#     district: Optional[str] = None
+
+
+# class AlertResponse(BaseModel):
+#     location: str
+#     coordinates: Dict[str, float]
+#     district: Optional[str] = None
+#     alert_summary: str
+#     timestamp: str
+
+
+# # ============================================================================
+# # API ENDPOINTS
+# # ============================================================================
+
+# @app.get("/")
+# async def root():
+#     """Root endpoint"""
+#     return {
+#         "message": "Farmer.chat Alert Summary API",
+#         "version": "1.0.0",
+#         "endpoints": {
+#             "/locations": "GET - List all districts and villages",
+#             "/generate-alert": "POST - Generate alert for location",
+#             "/health": "GET - Health check"
+#         }
+#     }
+
+
+# @app.get("/health")
+# async def health_check():
+#     """Health check endpoint"""
+#     return {
+#         "status": "healthy",
+#         "pipeline": "initialized" if pipeline else "not_initialized",
+#         "timestamp": datetime.now().isoformat()
+#     }
+
+
+# @app.get("/locations")
+# async def get_locations():
+#     """Get all districts and villages"""
+#     return {"districts": BIHAR_DATA}
+
+
+# @app.post("/generate-alert", response_model=AlertResponse)
+# async def generate_alert(request: LocationRequest):
+#     """Generate alert summary for selected location"""
+    
+#     if not pipeline:
+#         raise HTTPException(status_code=500, detail="Pipeline not initialized")
+    
+#     # Find location coordinates
+#     location_name = request.location_name.strip()
+#     coordinates = None
+    
+#     # Case-insensitive search
+#     for loc_key, loc_coords in LOCATIONS.items():
+#         if loc_key.lower() == location_name.lower():
+#             coordinates = loc_coords
+#             break
+    
+#     if not coordinates:
+#         raise HTTPException(
+#             status_code=404,
+#             detail=f"Location '{location_name}' not found in database"
+#         )
+    
+#     # Update pipeline location
+#     pipeline.location = coordinates
+    
+#     # Create comprehensive query for all MCP servers
+#     query = f"""Generate a comprehensive agricultural alert summary for {location_name} covering:
+# 1. Current weather conditions and 7-day forecast
+# 2. Soil health analysis and fertilizer recommendations
+# 3. Groundwater availability and irrigation status
+# 4. Elevation and topography considerations for farming
+# 5. Current pest risks and preventive measures
+
+# Provide actionable insights for farmers."""
+    
+#     try:
+#         # Generate alert
+#         alert_summary = pipeline.process_query(query)
+        
+#         return AlertResponse(
+#             location=location_name,
+#             coordinates=coordinates,
+#             district=request.district,
+#             alert_summary=alert_summary,
+#             timestamp=datetime.now().isoformat()
+#         )
+    
+#     except Exception as e:
+#         raise HTTPException(
+#             status_code=500,
+#             detail=f"Error generating alert: {str(e)}"
+#         )
+
+
+# # ============================================================================
+# # RUN SERVER
+# # ============================================================================
+
+# if __name__ == "__main__":
+#     import uvicorn
+#     port = int(os.getenv("PORT", 7860))
+#     uvicorn.run(app, host="0.0.0.0", port=port)
+
+
+
+"""
+Farmer.chat Alert Summary Generator - FastAPI Application
+Modular architecture with alert-focused intelligence
+"""
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import Optional, Dict
+from datetime import datetime
+import os
+
+# Import pipeline components
+from src.pipeline import FarmerChatPipeline
+
+# Import MCP servers (assuming they exist in src/servers/)
+from src.servers.weather import WeatherServer
+from src.servers.soil import SoilPropertiesServer
+from src.servers.water import WaterServer
+from src.servers.elevation import ElevationServer
+from src.servers.pests import PestsServer
+
+
+# ============================================================================
+# PYDANTIC MODELS
+# ============================================================================
+
+class LocationRequest(BaseModel):
+    """Request model for alert generation"""
+    location_name: str
+    district: Optional[str] = None
+
+
+class AlertResponse(BaseModel):
+    """Response model for generated alerts"""
+    location: str
+    coordinates: Dict[str, float]
+    district: Optional[str]
+    alert_summary: str
+    timestamp: str
+
+
+class QueryRequest(BaseModel):
+    """Request model for specific queries"""
+    query: str
+    location_name: Optional[str] = None
+    district: Optional[str] = None
+
+
+# ============================================================================
+# LOCATION DATA
+# ============================================================================
+
+BIHAR_DATA = {
+    "Araria": ["Araria", "Forbesganj", "Jokihat", "Raniganj"],
+    "Arwal": ["Arwal", "Kaler", "Karpi", "Kurtha"],
+    "Aurangabad": ["Aurangabad", "Daudnagar", "Obra", "Nabinagar"],
+    "Banka": ["Banka", "Amarpur", "Barahat", "Belhar"],
+    "Begusarai": ["Begusarai", "Bakhri", "Barauni", "Teghra"],
+    "Bhagalpur": ["Bhagalpur", "Sabour", "Nathnagar", "Kahalgaon"],
+    "Bhojpur": ["Arrah", "Jagdishpur", "Piro", "Shahpur"],
+    "Buxar": ["Buxar", "Dumraon", "Chausa", "Simri"],
+    "Darbhanga": ["Darbhanga", "Baheri", "Jale", "Benipur"],
+    "East Champaran": ["Motihari", "Raxaul", "Chakia", "Dhaka"],
+    "Gaya": ["Gaya", "Bodh Gaya", "Tekari", "Sherghati"],
+    "Gopalganj": ["Gopalganj", "Barauli", "Baikunthpur", "Kateya"],
+    "Jamui": ["Jamui", "Jhajha", "Sikandra", "Sono"],
+    "Jehanabad": ["Jehanabad", "Ghoshi", "Makhdumpur", "Modanganj"],
+    "Kaimur": ["Bhabua", "Mohania", "Ramgarh", "Chainpur"],
+    "Katihar": ["Katihar", "Barsoi", "Manihari", "Pranpur"],
+    "Khagaria": ["Khagaria", "Parbatta", "Alauli", "Beldaur"],
+    "Kishanganj": ["Kishanganj", "Bahadurganj", "Thakurganj", "Dighalbank"],
+    "Lakhisarai": ["Lakhisarai", "Halsi", "Suryagarha", "Pipariya"],
+    "Madhepura": ["Madhepura", "Udakishanganj", "Murliganj", "Alamnagar"],
+    "Madhubani": ["Madhubani", "Jhanjharpur", "Benipatti", "Jainagar"],
+    "Munger": ["Munger", "Jamalpur", "Asarganj", "Tarapur"],
+    "Muzaffarpur": ["Muzaffarpur", "Sitamarhi", "Minapur", "Bochaha"],
+    "Nalanda": ["Bihar Sharif", "Rajgir", "Hilsa", "Biharsharif"],
+    "Nawada": ["Nawada", "Rajauli", "Akbarpur", "Hisua"],
+    "Patna": ["Patna", "Danapur", "Fatuha", "Khagaul"],
+    "Purnia": ["Purnia", "Dhamdaha", "Kasba", "Banmankhi"],
+    "Rohtas": ["Sasaram", "Dehri", "Bikramganj", "Nasriganj"],
+    "Saharsa": ["Saharsa", "Sonbarsa", "Simri Bakhtiarpur", "Mahishi"],
+    "Samastipur": ["Samastipur", "Rosera", "Dalsinghsarai", "Pusa"],
+    "Saran": ["Chapra", "Marhaura", "Amnour", "Sonepur"],
+    "Sheikhpura": ["Sheikhpura", "Barbigha", "Ariari", "Shekhopur"],
+    "Sheohar": ["Sheohar", "Dumri Katsari", "Piprahi", "Tariyani"],
+    "Sitamarhi": ["Sitamarhi", "Pupri", "Belsand", "Bathnaha"],
+    "Siwan": ["Siwan", "Maharajganj", "Mairwa", "Darauli"],
+    "Supaul": ["Supaul", "Nirmali", "Triveniganj", "Chhatapur"],
+    "Vaishali": ["Hajipur", "Mahua", "Lalganj", "Desri"],
+    "West Champaran": ["Bettiah", "Bagaha", "Narkatiaganj", "Lauriya"]
+}
+
+LOCATIONS = {
+    "Araria": {"latitude": 26.1523, "longitude": 87.5167},
+    "Forbesganj": {"latitude": 26.3023, "longitude": 87.2664},
+    "Jokihat": {"latitude": 25.8998, "longitude": 87.2686},
+    "Raniganj": {"latitude": 26.0537, "longitude": 87.5333},
+    "Arwal": {"latitude": 25.2560, "longitude": 84.6819},
+    "Kaler": {"latitude": 25.1960, "longitude": 84.6219},
+    "Karpi": {"latitude": 25.2360, "longitude": 84.7019},
+    "Kurtha": {"latitude": 25.3160, "longitude": 84.6619},
+    "Aurangabad": {"latitude": 24.7521, "longitude": 84.3742},
+    "Daudnagar": {"latitude": 25.0337, "longitude": 84.4007},
+    "Obra": {"latitude": 24.9923, "longitude": 84.4342},
+    "Nabinagar": {"latitude": 24.6087, "longitude": 84.1269},
+    "Banka": {"latitude": 24.8893, "longitude": 86.9220},
+    "Amarpur": {"latitude": 25.0393, "longitude": 86.9020},
+    "Barahat": {"latitude": 24.8393, "longitude": 87.0020},
+    "Belhar": {"latitude": 24.9393, "longitude": 86.9620},
+    "Begusarai": {"latitude": 25.4182, "longitude": 86.1347},
+    "Bakhri": {"latitude": 25.4582, "longitude": 86.0547},
+    "Barauni": {"latitude": 25.4751, "longitude": 86.0458},
+    "Teghra": {"latitude": 25.5082, "longitude": 85.9347},
+    "Bhagalpur": {"latitude": 25.2425, "longitude": 86.9842},
+    "Sabour": {"latitude": 25.2375, "longitude": 87.0542},
+    "Nathnagar": {"latitude": 25.1225, "longitude": 87.0042},
+    "Kahalgaon": {"latitude": 25.1925, "longitude": 87.2142},
+    "Arrah": {"latitude": 25.5560, "longitude": 84.6631},
+    "Jagdishpur": {"latitude": 25.4660, "longitude": 84.4231},
+    "Piro": {"latitude": 25.3260, "longitude": 84.4031},
+    "Shahpur": {"latitude": 25.6060, "longitude": 84.4031},
+    "Buxar": {"latitude": 25.5641, "longitude": 83.9778},
+    "Dumraon": {"latitude": 25.5541, "longitude": 84.1478},
+    "Chausa": {"latitude": 25.5241, "longitude": 83.9178},
+    "Simri": {"latitude": 25.6141, "longitude": 84.0478},
+    "Darbhanga": {"latitude": 26.1542, "longitude": 85.8978},
+    "Baheri": {"latitude": 26.0442, "longitude": 85.8378},
+    "Jale": {"latitude": 26.2042, "longitude": 85.8578},
+    "Benipur": {"latitude": 26.1142, "longitude": 85.9478},
+    "Motihari": {"latitude": 26.6484, "longitude": 84.9194},
+    "Raxaul": {"latitude": 26.9784, "longitude": 84.8494},
+    "Chakia": {"latitude": 26.4184, "longitude": 85.0494},
+    "Dhaka": {"latitude": 26.6784, "longitude": 85.1694},
+    "Gaya": {"latitude": 24.7955, "longitude": 85.0002},
+    "Bodh Gaya": {"latitude": 24.6955, "longitude": 84.9902},
+    "Tekari": {"latitude": 24.9455, "longitude": 85.0402},
+    "Sherghati": {"latitude": 24.5655, "longitude": 84.7902},
+    "Gopalganj": {"latitude": 26.4685, "longitude": 84.4388},
+    "Barauli": {"latitude": 26.3785, "longitude": 84.5788},
+    "Baikunthpur": {"latitude": 26.5285, "longitude": 84.3588},
+    "Kateya": {"latitude": 26.4285, "longitude": 84.6388},
+    "Jamui": {"latitude": 24.9272, "longitude": 86.2231},
+    "Jhajha": {"latitude": 24.7772, "longitude": 86.3731},
+    "Sikandra": {"latitude": 24.9672, "longitude": 86.0631},
+    "Sono": {"latitude": 24.8372, "longitude": 86.1431},
+    "Jehanabad": {"latitude": 25.2078, "longitude": 84.9869},
+    "Ghoshi": {"latitude": 25.1478, "longitude": 84.9269},
+    "Makhdumpur": {"latitude": 25.2478, "longitude": 85.0469},
+    "Modanganj": {"latitude": 25.2678, "longitude": 84.9069},
+    "Bhabua": {"latitude": 25.0405, "longitude": 83.6074},
+    "Mohania": {"latitude": 25.1305, "longitude": 83.4774},
+    "Ramgarh": {"latitude": 24.9505, "longitude": 83.6874},
+    "Chainpur": {"latitude": 25.2005, "longitude": 83.7474},
+    "Katihar": {"latitude": 25.5394, "longitude": 87.5839},
+    "Barsoi": {"latitude": 25.3794, "longitude": 87.8839},
+    "Manihari": {"latitude": 25.3394, "longitude": 87.6239},
+    "Pranpur": {"latitude": 25.6894, "longitude": 87.7239},
+    "Khagaria": {"latitude": 25.5022, "longitude": 86.4665},
+    "Parbatta": {"latitude": 25.5422, "longitude": 86.5865},
+    "Alauli": {"latitude": 25.4622, "longitude": 86.3465},
+    "Beldaur": {"latitude": 25.5622, "longitude": 86.4265},
+    "Kishanganj": {"latitude": 26.1046, "longitude": 87.9475},
+    "Bahadurganj": {"latitude": 26.2646, "longitude": 88.1175},
+    "Thakurganj": {"latitude": 26.0446, "longitude": 87.8275},
+    "Dighalbank": {"latitude": 25.9046, "longitude": 87.9875},
+    "Lakhisarai": {"latitude": 25.1678, "longitude": 86.0927},
+    "Halsi": {"latitude": 25.2278, "longitude": 86.0327},
+    "Suryagarha": {"latitude": 25.1078, "longitude": 86.1527},
+    "Pipariya": {"latitude": 25.2078, "longitude": 86.1327},
+    "Madhepura": {"latitude": 25.9207, "longitude": 86.7940},
+    "Udakishanganj": {"latitude": 25.9807, "longitude": 86.6740},
+    "Murliganj": {"latitude": 25.8907, "longitude": 86.9940},
+    "Alamnagar": {"latitude": 25.9607, "longitude": 86.7340},
+    "Madhubani": {"latitude": 26.3561, "longitude": 86.0644},
+    "Jhanjharpur": {"latitude": 26.2661, "longitude": 86.2844},
+    "Benipatti": {"latitude": 26.5961, "longitude": 86.1444},
+    "Jainagar": {"latitude": 26.2061, "longitude": 86.1644},
+    "Munger": {"latitude": 25.3753, "longitude": 86.4734},
+    "Jamalpur": {"latitude": 25.3153, "longitude": 86.4934},
+    "Asarganj": {"latitude": 25.1453, "longitude": 86.6834},
+    "Tarapur": {"latitude": 25.0253, "longitude": 86.6334},
+    "Muzaffarpur": {"latitude": 26.1225, "longitude": 85.3906},
+    "Sitamarhi": {"latitude": 26.5925, "longitude": 85.4806},
+    "Minapur": {"latitude": 26.0625, "longitude": 85.2906},
+    "Bochaha": {"latitude": 26.0025, "longitude": 85.5306},
+    "Bihar Sharif": {"latitude": 25.1979, "longitude": 85.5238},
+    "Rajgir": {"latitude": 25.0279, "longitude": 85.4238},
+    "Hilsa": {"latitude": 25.3179, "longitude": 85.2838},
+    "Biharsharif": {"latitude": 25.1979, "longitude": 85.5238},
+    "Nawada": {"latitude": 24.8834, "longitude": 85.5387},
+    "Rajauli": {"latitude": 25.0634, "longitude": 85.6387},
+    "Akbarpur": {"latitude": 24.8234, "longitude": 85.4587},
+    "Hisua": {"latitude": 24.8334, "longitude": 85.4187},
+    "Patna": {"latitude": 25.5941, "longitude": 85.1376},
+    "Danapur": {"latitude": 25.6341, "longitude": 85.0476},
+    "Fatuha": {"latitude": 25.5041, "longitude": 85.3076},
+    "Khagaul": {"latitude": 25.5741, "longitude": 85.0476},
+    "Purnia": {"latitude": 25.7771, "longitude": 87.4753},
+    "Dhamdaha": {"latitude": 25.8871, "longitude": 87.5853},
+    "Kasba": {"latitude": 25.8471, "longitude": 87.5353},
+    "Banmankhi": {"latitude": 25.8871, "longitude": 87.1953},
+    "Sasaram": {"latitude": 24.9520, "longitude": 84.0328},
+    "Dehri": {"latitude": 24.9020, "longitude": 84.1828},
+    "Bikramganj": {"latitude": 25.2120, "longitude": 84.2628},
+    "Nasriganj": {"latitude": 25.0520, "longitude": 84.1228},
+    "Saharsa": {"latitude": 25.8769, "longitude": 86.5956},
+    "Sonbarsa": {"latitude": 25.9269, "longitude": 86.7356},
+    "Simri Bakhtiarpur": {"latitude": 25.9569, "longitude": 86.3556},
+    "Mahishi": {"latitude": 25.9969, "longitude": 86.4756},
+    "Samastipur": {"latitude": 25.8647, "longitude": 85.7817},
+    "Rosera": {"latitude": 25.7947, "longitude": 85.9317},
+    "Dalsinghsarai": {"latitude": 25.6647, "longitude": 85.8317},
+    "Pusa": {"latitude": 25.9847, "longitude": 85.6717},
+    "Chapra": {"latitude": 25.7805, "longitude": 84.7477},
+    "Marhaura": {"latitude": 25.9705, "longitude": 84.8677},
+    "Amnour": {"latitude": 25.8905, "longitude": 84.9077},
+    "Sonepur": {"latitude": 25.6905, "longitude": 85.1777},
+    "Sheikhpura": {"latitude": 25.1391, "longitude": 85.8354},
+    "Barbigha": {"latitude": 25.2191, "longitude": 85.7354},
+    "Ariari": {"latitude": 25.0591, "longitude": 85.9554},
+    "Shekhopur": {"latitude": 25.1391, "longitude": 85.8354},
+    "Sheohar": {"latitude": 26.5184, "longitude": 85.2959},
+    "Dumri Katsari": {"latitude": 26.5784, "longitude": 85.1959},
+    "Piprahi": {"latitude": 26.4684, "longitude": 85.4159},
+    "Tariyani": {"latitude": 26.5584, "longitude": 85.2359},
+    "Sitamarhi": {"latitude": 26.5925, "longitude": 85.4806},
+    "Pupri": {"latitude": 26.4725, "longitude": 85.7006},
+    "Belsand": {"latitude": 26.4425, "longitude": 85.4006},
+    "Bathnaha": {"latitude": 26.5925, "longitude": 85.5306},
+    "Siwan": {"latitude": 26.2195, "longitude": 84.3564},
+    "Maharajganj": {"latitude": 26.1095, "longitude": 84.5064},
+    "Mairwa": {"latitude": 26.2295, "longitude": 84.1664},
+    "Darauli": {"latitude": 26.1595, "longitude": 84.1464},
+    "Supaul": {"latitude": 26.1260, "longitude": 86.6050},
+    "Nirmali": {"latitude": 26.3160, "longitude": 86.5850},
+    "Triveniganj": {"latitude": 26.2160, "longitude": 87.0250},
+    "Chhatapur": {"latitude": 26.2160, "longitude": 86.9050},
+    "Hajipur": {"latitude": 25.6851, "longitude": 85.2095},
+    "Mahua": {"latitude": 25.9651, "longitude": 85.2895},
+    "Lalganj": {"latitude": 25.8751, "longitude": 85.1695},
+    "Desri": {"latitude": 25.6051, "longitude": 85.4895},
+    "Bettiah": {"latitude": 26.8022, "longitude": 84.5025},
+    "Bagaha": {"latitude": 27.0922, "longitude": 84.0925},
+    "Narkatiaganj": {"latitude": 26.4322, "longitude": 84.7925},
+    "Lauriya": {"latitude": 26.9822, "longitude": 84.3125}
+}
+
+
+# ============================================================================
+# FASTAPI APPLICATION
+# ============================================================================
+
+app = FastAPI(
+    title="Farmer.chat Alert Summary API",
+    description="Agricultural intelligence system with alert-focused MCP pipeline",
+    version="2.0.0"
+)
+
+# CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ============================================================================
+# GLOBAL STATE
+# ============================================================================
+
+pipeline: Optional[FarmerChatPipeline] = None
+servers: Dict = {}
+
+
+# ============================================================================
+# STARTUP & SHUTDOWN
+# ============================================================================
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize MCP servers and pipeline on startup"""
+    global pipeline, servers
+    
+    try:
+        print("\n" + "="*60)
+        print("Initializing Farmer.chat Alert System")
+        print("="*60 + "\n")
+        
+        # Initialize MCP servers
+        print("Initializing MCP servers...")
+        
+        # Note: Your servers don't need arguments in their constructors
+        # WaterServer hardcodes cache_dir internally
+        servers = {
+            "weather": WeatherServer(),
+            "soil": SoilPropertiesServer(),
+            "water": WaterServer(),
+            "elevation": ElevationServer(),
+            "pests": PestsServer()
+        }
+        
+        print("✓ All MCP servers initialized successfully\n")
+        
+        # Initialize pipeline with default location (Patna)
+        default_location = LOCATIONS.get("patna", {"latitude": 25.6093, "longitude": 85.1235})
+        
+        pipeline = FarmerChatPipeline(
+            servers=servers,
+            location=default_location
+        )
+        
+        print("\n" + "="*60)
+        print("✓ Farmer.chat Alert System Ready")
+        print("="*60 + "\n")
+        
+    except Exception as e:
+        print(f"✗ Pipeline initialization failed: {str(e)}")
+        raise
+
+
+@app.on_event("shutdown")
+async def shutdown_event():
+    """Cleanup on shutdown"""
+    print("\nShutting down Farmer.chat Alert System...")
+
+
+# ============================================================================
+# API ENDPOINTS
+# ============================================================================
+
+@app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "service": "Farmer.chat Alert Summary Generator",
+        "version": "2.0.0",
+        "status": "operational",
+        "architecture": "Modular MCP Pipeline",
+        "endpoints": {
+            "locations": "/locations - Get all available locations",
+            "generate_alert": "/generate-alert - Generate alert summary for location",
+            "query": "/query - Process specific farmer query",
+            "health": "/health - Health check",
+            "server_status": "/server-status - Check MCP server status"
+        }
+    }
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    if pipeline is None:
+        raise HTTPException(status_code=503, detail="Pipeline not initialized")
+    
+    return {
+        "status": "healthy",
+        "pipeline": "operational",
+        "servers": len(servers),
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
+
+@app.get("/server-status")
+async def server_status():
+    """Get status of all MCP servers"""
+    if pipeline is None:
+        raise HTTPException(status_code=503, detail="Pipeline not initialized")
+    
+    status = pipeline.get_server_status()
+    return {
+        "servers": status,
+        "timestamp": datetime.utcnow().isoformat()
+    }
+
+
+@app.get("/locations")
+async def get_locations():
+    """Get all available districts and villages"""
+    return {
+        "districts": BIHAR_DATA,
+        "total_locations": len(LOCATIONS),
+        "coverage": "Bihar, India"
+    }
+
+
+@app.post("/generate-alert", response_model=AlertResponse)
+async def generate_alert(request: LocationRequest):
+    """
+    Generate comprehensive alert summary for a location.
+    
+    Queries all MCP servers and compiles an actionable alert summary
+    focusing on critical information and recommendations.
+    """
+    
+    if pipeline is None:
+        raise HTTPException(status_code=503, detail="Pipeline not initialized")
+    
+    # Lookup location coordinates
+    location_key = request.location_name.lower().strip()
+    
+    if location_key not in LOCATIONS:
+        # Try case-insensitive partial match
+        matches = [k for k in LOCATIONS.keys() if location_key in k.lower()]
+        if matches:
+            location_key = matches[0]
+        else:
+            raise HTTPException(
+                status_code=404, 
+                detail=f"Location '{request.location_name}' not found in database"
+            )
+    
+    coordinates = LOCATIONS[location_key]
+    
+    try:
+        # Generate alert using pipeline
+        result = pipeline.generate_alert(
+            location=coordinates,
+            location_name=request.location_name
+        )
+        
+        return AlertResponse(
+            location=request.location_name,
+            coordinates=coordinates,
+            district=request.district,
+            alert_summary=result["alert_summary"],
+            timestamp=datetime.utcnow().isoformat()
+        )
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to generate alert: {str(e)}"
+        )
+
+
+@app.post("/query")
+async def process_query(request: QueryRequest):
+    """
+    Process a specific farmer query.
+    
+    Queries all MCP servers and returns a response focusing on
+    information relevant to the question.
+    """
+    
+    if pipeline is None:
+        raise HTTPException(status_code=503, detail="Pipeline not initialized")
+    
+    # Determine location
+    location = None
+    if request.location_name:
+        location_key = request.location_name.lower().strip()
+        if location_key in LOCATIONS:
+            location = LOCATIONS[location_key]
+        else:
+            matches = [k for k in LOCATIONS.keys() if location_key in k.lower()]
+            if matches:
+                location = LOCATIONS[matches[0]]
+    
+    try:
+        # Process query through pipeline
+        result = pipeline.process_query(
+            query=request.query,
+            location=location
+        )
+        
+        return {
+            "query": request.query,
+            "response": result["response"],
+            "location": result["location"],
+            "servers_queried": list(result["mcp_results"].keys()),
+            "timestamp": datetime.utcnow().isoformat()
+        }
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to process query: {str(e)}"
+        )
+
+
+# ============================================================================
+# MAIN (for local testing)
+# ============================================================================
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)
+

requirements.txt

@@ -0,0 +1,53 @@
+# Farmer.Chat Backend Dependencies]
+
+# # Web Framework
+# fastapi==0.109.0
+# uvicorn[standard]==0.27.0
+# python-multipart==0.0.6
+
+# openai==1.3.0
+# httpx==0.24.1
+# httpcore==0.17.3
+
+# # Async HTTP
+# aiohttp==3.9.1
+# aiofiles==23.2.1
+
+# # Data Processing
+# pandas==2.1.4
+# numpy==1.26.3
+# xarray==2023.12.0
+# netCDF4==1.6.5
+
+# # PDF Generation
+# reportlab==4.0.9
+# pillow==10.2.0
+
+# # Utilities
+# python-dotenv==1.0.0
+# pydantic==2.5.3
+# pydantic-settings==2.1.0
+
+# # Requests - updated for compatibility
+# requests==2.32.3
+
+# earthengine-api==0.1.384
+# google-auth==2.27.0
+# google-auth-httplib2==0.2.0
+
+fastapi==0.104.1
+uvicorn==0.24.0
+pydantic==2.5.0
+openai==1.3.0
+httpx==0.24.1
+python-multipart==0.0.6
+
+# MCP Server dependencies
+requests==2.31.0
+numpy==1.24.3
+xarray==2023.1.0
+netCDF4==1.6.4
+earthengine-api==0.1.374
+scipy==1.10.1
+rasterio==1.3.9
+h5netcdf==1.2.0

src/__init__.py

@@ -0,0 +1,37 @@
+# """
+# Farmer.Chat Backend - MCP Pipeline Package
+# """
+
+# # Import main components
+# from .pipeline import FarmerChatPipeline
+# from .router import QueryRouter
+# from .executor import MCPExecutor, MCP_SERVER_REGISTRY
+# from .compiler import ResponseCompiler
+# from .translator import FarmerTranslator
+# from .pdf_generator import generate_pdf_report
+
+# __all__ = [
+#     'FarmerChatPipeline',
+#     'QueryRouter',
+#     'MCPExecutor',
+#     'MCP_SERVER_REGISTRY',
+#     'ResponseCompiler',
+#     'FarmerTranslator',
+#     'generate_pdf_report'
+# ]
+
+"""
+Farmer.chat Alert System - Modular Components
+"""
+
+from .pipeline import FarmerChatPipeline
+from .router import QueryRouter
+from .executor import MCPExecutor
+from .compiler import ResponseCompiler
+
+__all__ = [
+    'FarmerChatPipeline',
+    'QueryRouter', 
+    'MCPExecutor',
+    'ResponseCompiler'
+]

src/compiler.py

@@ -0,0 +1,265 @@
+# """
+# Stage 3: Response Compiler - Data Fusion
+# """
+
+# from typing import Dict, Any, List
+
+
+# class ResponseCompiler:
+#     """Stage 3: Compile results from multiple servers"""
+
+#     def compile(self, raw_results: Dict[str, Any]) -> Dict[str, Any]:
+#         """
+#         Merge results into structured format
+        
+#         Args:
+#             raw_results: Dictionary containing results from MCPExecutor
+#                 {
+#                     "results": {
+#                         "weather": {"status": "success", "data": {...}},
+#                         "soil_properties": {"status": "success", "data": {...}},
+#                         ...
+#                     },
+#                     "execution_time_seconds": 3.5
+#                 }
+        
+#         Returns:
+#             {
+#                 "successful_servers": List[str],
+#                 "failed_servers": List[dict],
+#                 "data": Dict[str, Any],
+#                 "execution_time": float,
+#                 "completeness": str
+#             }
+#         """
+#         results_dict = raw_results.get("results", {})
+
+#         successful = []
+#         failed = []
+#         compiled_data = {}
+
+#         for server_name, result in results_dict.items():
+#             if result.get("status") == "success":
+#                 successful.append(server_name)
+#                 compiled_data[server_name] = result.get("data", {})
+#             else:
+#                 failed.append({
+#                     "server": server_name,
+#                     "error": result.get("error", "Unknown error")
+#                 })
+
+#         return {
+#             "successful_servers": successful,
+#             "failed_servers": failed,
+#             "data": compiled_data,
+#             "execution_time": raw_results.get("execution_time_seconds", 0),
+#             "completeness": f"{len(successful)}/{len(results_dict)} servers"
+#         }
+
+"""
+Response Compiler - Stage 3
+Compiles MCP results with focus on ALERTING INFORMATION ONLY
+"""
+
+from typing import Dict, Any
+from openai import OpenAI
+import httpx
+import os
+
+
+class ResponseCompiler:
+    """
+    Compiles MCP server results into alert-focused responses.
+    
+    KEY PRINCIPLE: All MCPs are queried, but the compiler extracts ONLY
+    the alerting, concerning, or actionable information. Normal/good status
+    is minimized or omitted entirely.
+    """
+    
+    def __init__(self):
+        """Initialize compiler with OpenAI client"""
+        api_key = os.getenv("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable not set")
+        
+        # Create custom httpx client without proxies parameter (compatibility fix)
+        http_client = httpx.Client(
+            timeout=httpx.Timeout(60.0, connect=10.0),
+            limits=httpx.Limits(max_keepalive_connections=10, max_connections=20)
+        )
+        
+        self.client = OpenAI(api_key=api_key, http_client=http_client)
+    
+    def compile_alert_summary(
+        self, 
+        mcp_results: Dict[str, Any], 
+        location: Dict[str, float],
+        location_name: str = ""
+    ) -> str:
+        """
+        Compile MCP results into alert summary focusing ONLY on concerning information.
+        
+        This is where the intelligence lives - not in routing. All MCP servers are
+        queried, but we extract only what farmers need to act on.
+        
+        Args:
+            mcp_results: Results from all MCP servers
+            location: Dict with 'latitude' and 'longitude' keys
+            location_name: Optional human-readable location name
+            
+        Returns:
+            Alert summary highlighting only actionable concerns
+        """
+        
+        # Build comprehensive context from all MCP data
+        context_parts = []
+        
+        for server_name, result in mcp_results.items():
+            if result["status"] == "success" and result["data"]:
+                context_parts.append(f"=== {server_name.upper()} DATA ===\n{result['data']}")
+        
+        if not context_parts:
+            return "Unable to generate alert summary - no data available from MCP servers."
+        
+        full_context = "\n\n".join(context_parts)
+        location_str = f"{location_name} ({location['latitude']:.4f}°N, {location['longitude']:.4f}°E)"
+        
+        # THE KEY PROMPT: Extract only alerting information
+        prompt = f"""You are an agricultural alert analyst. Your task is to analyze comprehensive agricultural data and extract ONLY the alerting, concerning, or time-sensitive information.
+
+LOCATION: {location_str}
+
+COMPREHENSIVE DATA FROM ALL MONITORING SYSTEMS:
+{full_context}
+
+YOUR TASK:
+Generate a concise ALERT SUMMARY that includes ONLY:
+
+1. **CRITICAL ALERTS** - Immediate threats requiring urgent action:
+   - Extreme weather conditions (heat waves, storms, frost)
+   - Active pest/disease outbreaks
+   - Severe water scarcity or excess
+   - Soil contamination or extreme deficiencies
+   
+2. **IMPORTANT WARNINGS** - Developing issues requiring attention:
+   - Concerning trends (declining water table, degrading soil)
+   - Moderate pest pressure building up
+   - Suboptimal weather patterns affecting crops
+   - Nutrient imbalances needing correction
+
+3. **ACTIONABLE RECOMMENDATIONS** - What farmers should do:
+   - Specific actions with timing
+   - Preventive measures
+   - Mitigation strategies
+
+CRITICAL RULES:
+- OMIT all normal/good status information unless it provides important context
+- If weather is normal → DON'T mention it or say "Weather: Normal" briefly
+- If soil is healthy → SKIP or say "Soil: No concerns" briefly  
+- If no pest activity → SKIP or say "Pests: No threats detected" briefly
+- FOCUS on deviations from normal, risks, and time-sensitive items
+- Use specific numbers/dates only when they convey urgency
+- Maximum 400 words total
+- If everything is fine, say so clearly upfront then provide brief context
+
+Structure:
+1. Status Line: "CRITICAL ALERTS DETECTED" or "NO CRITICAL ALERTS - FAVORABLE CONDITIONS"
+2. Critical Alerts section (if any)
+3. Important Warnings section (if any)
+4. Recommended Actions (always include if alerts/warnings exist)
+5. Add raw API output in JSON format at end for reference.
+
+Be direct. Skip pleasantries. Farmers need to know what matters."""
+
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {
+                        "role": "system", 
+                        "content": "You are an expert agricultural alert analyst. Extract ONLY concerning, alerting, or actionable information. Omit normal status unless contextually necessary."
+                    },
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.2,
+                max_tokens=1000
+            )
+            
+            return response.choices[0].message.content.strip()
+            
+        except Exception as e:
+            print(f"⚠️ Compilation error: {e}")
+            return self._create_fallback_summary(mcp_results, location_str)
+    
+    def compile_response(
+        self, 
+        query: str, 
+        mcp_results: Dict[str, Any], 
+        location: Dict[str, float]
+    ) -> str:
+        """
+        Compile MCP results into a response for a specific query.
+        
+        Args:
+            query: User's original query
+            mcp_results: Results from MCP servers
+            location: Dict with 'latitude' and 'longitude' keys
+            
+        Returns:
+            Compiled response text focusing on query-relevant information
+        """
+        
+        # Format MCP results for context
+        context_parts = []
+        for server_name, result in mcp_results.items():
+            if result["status"] == "success" and result["data"]:
+                context_parts.append(f"{server_name.upper()}: {result['data']}")
+        
+        context = "\n\n".join(context_parts)
+        
+        prompt = f"""Answer this farmer's question using the provided data, focusing on actionable insights.
+
+QUESTION: {query}
+LOCATION: {location['latitude']:.4f}°N, {location['longitude']:.4f}°E
+
+AVAILABLE DATA:
+{context}
+
+Provide a focused answer that:
+1. Directly addresses the question
+2. Highlights any concerning information relevant to the query
+3. Gives specific recommendations
+4. Keeps explanations brief and practical
+5. Omits irrelevant normal/good status information
+6. Add Raw API Output from all MCP Servers at the end for reference.
+
+Be conversational but professional. Skip unnecessary background unless it aids understanding."""
+
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {"role": "system", "content": "You are a knowledgeable agricultural advisor providing practical guidance to farmers."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.5,
+                max_tokens=800
+            )
+            
+            return response.choices[0].message.content.strip()
+            
+        except Exception as e:
+            print(f"⚠️ Compilation error: {e}")
+            return f"Error compiling response: {str(e)}"
+    
+    def _create_fallback_summary(self, mcp_results: Dict[str, Any], location_str: str) -> str:
+        """Create basic fallback summary if LLM compilation fails"""
+        
+        summary_parts = [f"Alert Summary for {location_str}\n\n"]
+        
+        for server_name, result in mcp_results.items():
+            if result["status"] == "success" and result["data"]:
+                summary_parts.append(f"{server_name.upper()}:")
+                summary_parts.append(str(result["data"])[:300] + "...\n")
+        
+        return "\n".join(summary_parts)

src/executor.py

@@ -0,0 +1,481 @@
+# """
+# Stage 2: MCP Executor - Parallel API Execution
+# """
+
+# import asyncio
+# import time
+# from typing import List, Dict, Any
+
+# from .servers.weather import WeatherServer
+# from .servers.soil import SoilPropertiesServer
+# from .servers.water import WaterServer
+# from .servers.elevation import ElevationServer
+# from .servers.pests import PestsServer
+
+
+# # MCP Server Registry
+# MCP_SERVER_REGISTRY = {
+#     "weather": {
+#         "name": "Weather Server (Open-Meteo)",
+#         "description": "Current weather and 7-day forecasts: temperature, precipitation, wind, humidity",
+#         "capabilities": ["current_weather", "weather_forecast", "rainfall_prediction", "temperature_trends"],
+#         "use_for": ["rain", "temperature", "weather", "forecast", "frost", "wind"]
+#     },
+#     "soil_properties": {
+#         "name": "Soil Properties Server (SoilGrids)",
+#         "description": "Soil composition: clay, sand, silt, pH, organic matter from global soil database",
+#         "capabilities": ["soil_texture", "soil_ph", "clay_content", "sand_content", "nutrients"],
+#         "use_for": ["soil", "pH", "texture", "clay", "sand", "composition", "fertility", "nutrients"]
+#     },
+#     "water": {
+#         "name": "Groundwater Server (GRACE)",
+#         "description": "Groundwater levels and drought indicators from NASA GRACE satellite data",
+#         "capabilities": ["groundwater_levels", "drought_status", "water_storage", "soil_moisture"],
+#         "use_for": ["groundwater", "drought", "water", "irrigation", "water stress", "moisture"]
+#     },
+#     "elevation": {
+#         "name": "Elevation Server (OpenElevation)",
+#         "description": "Field elevation and terrain data for irrigation planning",
+#         "capabilities": ["elevation", "terrain_analysis"],
+#         "use_for": ["elevation", "slope", "terrain", "drainage"]
+#     },
+#     "pests": {
+#         "name": "Pest Observation Server (iNaturalist)",
+#         "description": "Recent pest and insect observations from community reporting",
+#         "capabilities": ["pest_observations", "disease_reports", "pest_distribution"],
+#         "use_for": ["pests", "insects", "disease", "outbreak"]
+#     }
+# }
+
+
+# class MCPExecutor:
+#     """Stage 2: Execute API calls in parallel"""
+
+#     def __init__(self):
+#         self.servers = {
+#             "weather": WeatherServer(),
+#             "soil_properties": SoilPropertiesServer(),
+#             "water": WaterServer(),
+#             "elevation": ElevationServer(),
+#             "pests": PestsServer()
+#         }
+
+#     async def execute_parallel(self, server_names: List[str], lat: float, lon: float) -> Dict[str, Any]:
+#         """
+#         Call multiple servers simultaneously
+        
+#         Returns:
+#             {
+#                 "results": {
+#                     "weather": {"status": "success", "data": {...}},
+#                     ...
+#                 },
+#                 "execution_time_seconds": float
+#             }
+#         """
+#         start_time = time.time()
+
+#         tasks = []
+#         valid_servers = []
+
+#         for name in server_names:
+#             if name in self.servers:
+#                 tasks.append(self.servers[name].get_data(lat, lon))
+#                 valid_servers.append(name)
+#             else:
+#                 print(f"⚠️ Unknown server: {name}")
+
+#         # Execute all in parallel
+#         results = await asyncio.gather(*tasks, return_exceptions=True)
+
+#         # Format results
+#         formatted_results = {}
+#         for i, server_name in enumerate(valid_servers):
+#             result = results[i]
+#             if isinstance(result, Exception):
+#                 formatted_results[server_name] = {
+#                     "status": "error",
+#                     "error": str(result)
+#                 }
+#             else:
+#                 formatted_results[server_name] = result
+
+#         elapsed_time = time.time() - start_time
+
+#         return {
+#             "results": formatted_results,
+#             "execution_time_seconds": round(elapsed_time, 2)
+#         }
+
+# """
+# MCP Executor - Stage 2
+# Executes parallel calls to MCP servers based on routing decisions
+# """
+
+# from typing import Dict, Any
+# from concurrent.futures import ThreadPoolExecutor, as_completed
+# import asyncio
+
+
+# class MCPExecutor:
+#     """
+#     Executes MCP server calls based on routing decisions.
+#     Integrates with existing server implementations in src/servers/
+#     Handles both sync and async server methods.
+#     """
+    
+#     def __init__(self, servers: Dict[str, Any]):
+#         """
+#         Initialize executor with MCP server instances.
+        
+#         Args:
+#             servers: Dict mapping server names to initialized server objects
+#                     e.g., {"weather": WeatherServer(), "soil": SoilPropertiesServer(), ...}
+#         """
+#         self.servers = servers
+    
+#     def execute_parallel(self, routing: Dict[str, bool], location: Dict[str, float]) -> Dict[str, Any]:
+#         """
+#         Execute MCP server calls in parallel based on routing.
+        
+#         Args:
+#             routing: Simple dict with server names as keys and True/False as values
+#             location: Dict with 'latitude' and 'longitude' keys
+            
+#         Returns:
+#             Dict mapping server names to their results with metadata
+#         """
+#         results = {}
+#         tasks = []
+        
+#         # Prepare tasks for servers marked for querying
+#         for server_name, should_query in routing.items():
+#             if should_query and server_name in self.servers:
+#                 tasks.append({
+#                     "server_name": server_name,
+#                     "server": self.servers[server_name],
+#                     "location": location
+#                 })
+        
+#         # Execute in parallel using ThreadPoolExecutor
+#         with ThreadPoolExecutor(max_workers=5) as executor:
+#             futures = {
+#                 executor.submit(self._call_server_sync, task): task 
+#                 for task in tasks
+#             }
+            
+#             for future in as_completed(futures):
+#                 task = futures[future]
+#                 server_name = task["server_name"]
+                
+#                 try:
+#                     result = future.result(timeout=30)
+#                     results[server_name] = {
+#                         "data": result,
+#                         "status": "success"
+#                     }
+#                     print(f"✓ {server_name.upper()}: Retrieved successfully")
+                    
+#                 except Exception as e:
+#                     results[server_name] = {
+#                         "data": None,
+#                         "status": "error",
+#                         "error": str(e)
+#                     }
+#                     print(f"✗ {server_name.upper()}: Error - {str(e)}")
+        
+#         return results
+    
+#     def _call_server_sync(self, task: Dict[str, Any]) -> Any:
+#         """
+#         Call individual MCP server, handling both sync and async methods.
+        
+#         Args:
+#             task: Dict containing server, location, and metadata
+            
+#         Returns:
+#             Server response data
+#         """
+#         server = task["server"]
+#         location = task["location"]
+        
+#         # Try async method first (most of your servers use async)
+#         if hasattr(server, 'get_data'):
+#             method = getattr(server, 'get_data')
+            
+#             # Check if it's async
+#             if asyncio.iscoroutinefunction(method):
+#                 # Run async method in new event loop
+#                 try:
+#                     loop = asyncio.new_event_loop()
+#                     asyncio.set_event_loop(loop)
+#                     result = loop.run_until_complete(
+#                         method(location['latitude'], location['longitude'])
+#                     )
+#                     loop.close()
+#                     return result
+#                 except Exception as e:
+#                     raise Exception(f"Async execution failed: {str(e)}")
+#             else:
+#                 # Sync method
+#                 return method(location['latitude'], location['longitude'])
+        
+#         # Fallback to other method names
+#         elif hasattr(server, 'query'):
+#             return server.query(location)
+#         elif hasattr(server, 'fetch_data'):
+#             return server.fetch_data(location['latitude'], location['longitude'])
+#         else:
+#             raise AttributeError(f"Server {task['server_name']} has no compatible query method")
+    
+#     def execute_sequential(self, routing: Dict[str, bool], location: Dict[str, float]) -> Dict[str, Any]:
+#         """
+#         Execute MCP server calls sequentially (fallback if parallel fails).
+        
+#         Args:
+#             routing: Simple dict with server names as keys and True/False as values
+#             location: Dict with 'latitude' and 'longitude' keys
+            
+#         Returns:
+#             Dict mapping server names to their results
+#         """
+#         results = {}
+        
+#         for server_name, should_query in routing.items():
+#             if should_query and server_name in self.servers:
+#                 try:
+#                     task = {
+#                         "server_name": server_name,
+#                         "server": self.servers[server_name],
+#                         "location": location
+#                     }
+                    
+#                     result = self._call_server_sync(task)
+#                     results[server_name] = {
+#                         "data": result,
+#                         "status": "success"
+#                     }
+#                     print(f"✓ {server_name.upper()}: Retrieved successfully")
+                    
+#                 except Exception as e:
+#                     results[server_name] = {
+#                         "data": None,
+#                         "status": "error",
+#                         "error": str(e)
+#                     }
+#                     print(f"✗ {server_name.upper()}: Error - {str(e)}")
+        
+#         return results
+        
+#         return results
+
+"""
+MCP Executor - Stage 2
+Executes parallel calls to MCP servers based on routing decisions
+FIXED: Simpler async handling to prevent deadlocks
+"""
+
+from typing import Dict, Any
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import asyncio
+import inspect
+
+
+class MCPExecutor:
+    """
+    Executes MCP server calls based on routing decisions.
+    Integrates with existing server implementations in src/servers/
+    Handles both sync and async server methods safely.
+    """
+    
+    def __init__(self, servers: Dict[str, Any]):
+        """
+        Initialize executor with MCP server instances.
+        
+        Args:
+            servers: Dict mapping server names to initialized server objects
+                    e.g., {"weather": WeatherServer(), "soil": SoilPropertiesServer(), ...}
+        """
+        self.servers = servers
+    
+    def execute_parallel(self, routing: Dict[str, bool], location: Dict[str, float]) -> Dict[str, Any]:
+        """
+        Execute MCP server calls in parallel based on routing.
+        
+        Args:
+            routing: Simple dict with server names as keys and True/False as values
+            location: Dict with 'latitude' and 'longitude' keys
+            
+        Returns:
+            Dict mapping server names to their results with metadata
+        """
+        results = {}
+        
+        # For async servers, we need to run them differently
+        # Separate sync and async servers
+        sync_tasks = []
+        async_tasks = []
+        
+        for server_name, should_query in routing.items():
+            if should_query and server_name in self.servers:
+                server = self.servers[server_name]
+                task = {
+                    "server_name": server_name,
+                    "server": server,
+                    "location": location
+                }
+                
+                # Check if server method is async
+                if hasattr(server, 'get_data'):
+                    method = getattr(server, 'get_data')
+                    if inspect.iscoroutinefunction(method):
+                        async_tasks.append(task)
+                    else:
+                        sync_tasks.append(task)
+                else:
+                    sync_tasks.append(task)
+        
+        # Execute sync servers in parallel with ThreadPoolExecutor
+        if sync_tasks:
+            with ThreadPoolExecutor(max_workers=5) as executor:
+                futures = {
+                    executor.submit(self._call_sync_server, task): task 
+                    for task in sync_tasks
+                }
+                
+                for future in as_completed(futures):
+                    task = futures[future]
+                    server_name = task["server_name"]
+                    
+                    try:
+                        result = future.result(timeout=30)
+                        results[server_name] = {
+                            "data": result,
+                            "status": "success"
+                        }
+                        print(f"✓ {server_name.upper()}: Retrieved successfully")
+                    except Exception as e:
+                        results[server_name] = {
+                            "data": None,
+                            "status": "error",
+                            "error": str(e)
+                        }
+                        print(f"✗ {server_name.upper()}: Error - {str(e)}")
+        
+        # Execute async servers together in single event loop
+        if async_tasks:
+            try:
+                async_results = asyncio.run(self._execute_async_batch(async_tasks))
+                results.update(async_results)
+            except Exception as e:
+                # If batch fails, mark all as failed
+                for task in async_tasks:
+                    results[task["server_name"]] = {
+                        "data": None,
+                        "status": "error",
+                        "error": f"Async batch execution failed: {str(e)}"
+                    }
+                    print(f"✗ {task['server_name'].upper()}: Async batch error")
+        
+        return results
+    
+    async def _execute_async_batch(self, tasks: list) -> Dict[str, Any]:
+        """
+        Execute multiple async server calls concurrently in a single event loop.
+        This is safer than creating multiple event loops.
+        """
+        results = {}
+        
+        # Create async tasks for all servers
+        async_calls = []
+        for task in tasks:
+            async_calls.append(self._call_async_server(task))
+        
+        # Execute all async calls concurrently
+        task_results = await asyncio.gather(*async_calls, return_exceptions=True)
+        
+        # Process results
+        for task, result in zip(tasks, task_results):
+            server_name = task["server_name"]
+            
+            if isinstance(result, Exception):
+                results[server_name] = {
+                    "data": None,
+                    "status": "error",
+                    "error": str(result)
+                }
+                print(f"✗ {server_name.upper()}: Error - {str(result)}")
+            else:
+                results[server_name] = {
+                    "data": result,
+                    "status": "success"
+                }
+                print(f"✓ {server_name.upper()}: Retrieved successfully")
+        
+        return results
+    
+    async def _call_async_server(self, task: Dict[str, Any]) -> Any:
+        """Call individual async MCP server"""
+        server = task["server"]
+        location = task["location"]
+        
+        if hasattr(server, 'get_data'):
+            return await server.get_data(location['latitude'], location['longitude'])
+        else:
+            raise AttributeError(f"Server {task['server_name']} has no get_data method")
+    
+    def _call_sync_server(self, task: Dict[str, Any]) -> Any:
+        """Call individual sync MCP server"""
+        server = task["server"]
+        location = task["location"]
+        
+        if hasattr(server, 'get_data'):
+            return server.get_data(location['latitude'], location['longitude'])
+        elif hasattr(server, 'query'):
+            return server.query(location)
+        elif hasattr(server, 'fetch_data'):
+            return server.fetch_data(location['latitude'], location['longitude'])
+        else:
+            raise AttributeError(f"Server {task['server_name']} has no compatible query method")
+    
+    def execute_sequential(self, routing: Dict[str, bool], location: Dict[str, float]) -> Dict[str, Any]:
+        """
+        Execute MCP server calls sequentially (fallback if parallel fails).
+        """
+        results = {}
+        
+        for server_name, should_query in routing.items():
+            if should_query and server_name in self.servers:
+                try:
+                    server = self.servers[server_name]
+                    
+                    # Check if async
+                    if hasattr(server, 'get_data') and inspect.iscoroutinefunction(server.get_data):
+                        # Run async method
+                        result = asyncio.run(server.get_data(location['latitude'], location['longitude']))
+                    else:
+                        # Run sync method
+                        task = {
+                            "server_name": server_name,
+                            "server": server,
+                            "location": location
+                        }
+                        result = self._call_sync_server(task)
+                    
+                    results[server_name] = {
+                        "data": result,
+                        "status": "success"
+                    }
+                    print(f"✓ {server_name.upper()}: Retrieved successfully")
+                    
+                except Exception as e:
+                    results[server_name] = {
+                        "data": None,
+                        "status": "error",
+                        "error": str(e)
+                    }
+                    print(f"✗ {server_name.upper()}: Error - {str(e)}")
+        
+        return results
+        
+        return results

src/pdf_generator.py

@@ -0,0 +1,162 @@
+"""
+PDF Report Generator for Farmer.Chat
+Exports query results as downloadable PDF
+"""
+
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, PageBreak
+from reportlab.lib import colors
+from reportlab.lib.enums import TA_CENTER, TA_LEFT
+from datetime import datetime
+import json
+import os
+from typing import Dict, Any
+
+
+def generate_pdf_report(
+    query: str,
+    advice: str,
+    data: Dict[str, Any],
+    location: Dict[str, Any]
+) -> str:
+    """
+    Generate PDF report from query results
+    
+    Args:
+        query: Farmer's question
+        advice: Generated advice
+        data: Compiled data from MCP servers
+        location: Location information
+    
+    Returns:
+        str: Path to generated PDF file
+    """
+    # Create output directory
+    output_dir = "./pdf_reports"
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Generate filename
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"farmer_chat_report_{timestamp}.pdf"
+    filepath = os.path.join(output_dir, filename)
+    
+    # Create PDF
+    doc = SimpleDocTemplate(filepath, pagesize=letter)
+    story = []
+    styles = getSampleStyleSheet()
+    
+    # Custom styles
+    title_style = ParagraphStyle(
+        'CustomTitle',
+        parent=styles['Heading1'],
+        fontSize=24,
+        textColor=colors.HexColor('#2E7D32'),
+        spaceAfter=30,
+        alignment=TA_CENTER
+    )
+    
+    heading_style = ParagraphStyle(
+        'CustomHeading',
+        parent=styles['Heading2'],
+        fontSize=16,
+        textColor=colors.HexColor('#1B5E20'),
+        spaceAfter=12,
+        spaceBefore=20
+    )
+    
+    # Title
+    story.append(Paragraph("🌾 Farmer.Chat Report", title_style))
+    story.append(Spacer(1, 0.2*inch))
+    
+    # Metadata section
+    metadata_data = [
+        ["Report Generated:", datetime.now().strftime("%B %d, %Y at %I:%M %p")],
+        ["Location:", f"{location['name']}"],
+        ["Coordinates:", f"{location['lat']}°N, {location['lon']}°E"],
+        ["Data Sources:", f"{len(data.get('successful_servers', []))} MCP Servers"]
+    ]
+    
+    metadata_table = Table(metadata_data, colWidths=[2*inch, 4*inch])
+    metadata_table.setStyle(TableStyle([
+        ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#E8F5E9')),
+        ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+        ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+        ('FONTNAME', (0, 0), (0, -1), 'Helvetica-Bold'),
+        ('FONTNAME', (1, 0), (1, -1), 'Helvetica'),
+        ('FONTSIZE', (0, 0), (-1, -1), 10),
+        ('BOTTOMPADDING', (0, 0), (-1, -1), 8),
+        ('GRID', (0, 0), (-1, -1), 1, colors.grey)
+    ]))
+    
+    story.append(metadata_table)
+    story.append(Spacer(1, 0.3*inch))
+    
+    # Query section
+    story.append(Paragraph("Your Query", heading_style))
+    story.append(Paragraph(query, styles['Normal']))
+    story.append(Spacer(1, 0.2*inch))
+    
+    # Advice section
+    story.append(Paragraph("Recommendations", heading_style))
+    
+    # Split advice into paragraphs
+    advice_paragraphs = advice.split('\n\n')
+    for para in advice_paragraphs:
+        if para.strip():
+            story.append(Paragraph(para.strip(), styles['Normal']))
+            story.append(Spacer(1, 0.1*inch))
+    
+    story.append(Spacer(1, 0.2*inch))
+    
+    # Data section
+    story.append(Paragraph("Data Sources", heading_style))
+    
+    compiled_data = data.get('data', {})
+    
+    for server_name, server_data in compiled_data.items():
+        # Server heading
+        server_title = server_name.replace('_', ' ').title()
+        story.append(Paragraph(f"<b>{server_title}</b>", styles['Normal']))
+        story.append(Spacer(1, 0.05*inch))
+        
+        # Server data table
+        server_items = []
+        if isinstance(server_data, dict):
+            for key, value in server_data.items():
+                if isinstance(value, (str, int, float)):
+                    display_key = key.replace('_', ' ').title()
+                    server_items.append([display_key, str(value)])
+        
+        if server_items:
+            data_table = Table(server_items, colWidths=[2.5*inch, 3.5*inch])
+            data_table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (0, -1), colors.HexColor('#F1F8E9')),
+                ('TEXTCOLOR', (0, 0), (-1, -1), colors.black),
+                ('ALIGN', (0, 0), (-1, -1), 'LEFT'),
+                ('FONTNAME', (0, 0), (0, -1), 'Helvetica'),
+                ('FONTNAME', (1, 0), (1, -1), 'Helvetica'),
+                ('FONTSIZE', (0, 0), (-1, -1), 9),
+                ('BOTTOMPADDING', (0, 0), (-1, -1), 6),
+                ('GRID', (0, 0), (-1, -1), 0.5, colors.grey)
+            ]))
+            story.append(data_table)
+            story.append(Spacer(1, 0.15*inch))
+    
+    # Footer
+    story.append(Spacer(1, 0.3*inch))
+    footer_style = ParagraphStyle(
+        'Footer',
+        parent=styles['Normal'],
+        fontSize=9,
+        textColor=colors.grey,
+        alignment=TA_CENTER
+    )
+    story.append(Paragraph("Generated by Farmer.Chat - Agricultural Intelligence System", footer_style))
+    story.append(Paragraph("Powered by Multi-stage MCP Pipeline", footer_style))
+    
+    # Build PDF
+    doc.build(story)
+    
+    return filepath

src/pipeline.py

@@ -0,0 +1,277 @@
+# """
+# Complete Multi-Stage MCP Pipeline
+# Orchestrates: Router → Executor → Compiler → Translator
+# """
+
+# import time
+# from typing import Dict, Any
+# from openai import OpenAI
+
+# from .router import QueryRouter
+# from .executor import MCPExecutor, MCP_SERVER_REGISTRY
+# from .compiler import ResponseCompiler
+# from .translator import FarmerTranslator
+
+
+# class FarmerChatPipeline:
+#     """Complete multi-stage MCP pipeline"""
+
+#     def __init__(self, openai_client: OpenAI, location: Dict[str, Any]):
+#         self.location = location
+#         self.router = QueryRouter(openai_client, MCP_SERVER_REGISTRY)
+#         self.executor = MCPExecutor()
+#         self.compiler = ResponseCompiler()
+#         self.translator = FarmerTranslator(openai_client)
+
+#     async def process_query(self, query: str, verbose: bool = False) -> Dict[str, Any]:
+#         """
+#         Process farmer query through complete pipeline
+        
+#         Returns:
+#             {
+#                 "query": str,
+#                 "routing": dict,
+#                 "compiled_data": dict,
+#                 "advice": str,
+#                 "pipeline_time_seconds": float
+#             }
+#         """
+#         if verbose:
+#             print(f"\n🌾 Processing: {query}")
+#             print(f"📍 Location: {self.location['name']}")
+
+#         pipeline_start = time.time()
+
+#         # STAGE 1: Query Routing
+#         if verbose:
+#             print("🎯 Stage 1: Routing...")
+        
+#         routing = self.router.route(query, self.location)
+        
+#         if verbose:
+#             print(f"   → Servers: {', '.join(routing['required_servers'])}")
+
+#         # STAGE 2: MCP Execution (Parallel)
+#         if verbose:
+#             print("⚙️ Stage 2: Executing MCP servers...")
+        
+#         raw_results = await self.executor.execute_parallel(
+#             routing['required_servers'],
+#             self.location['lat'],
+#             self.location['lon']
+#         )
+        
+#         if verbose:
+#             print(f"   → Completed in {raw_results['execution_time_seconds']}s")
+
+#         # STAGE 3: Response Compilation
+#         if verbose:
+#             print("🔗 Stage 3: Compiling results...")
+        
+#         compiled = self.compiler.compile(raw_results)
+        
+#         if verbose:
+#             print(f"   → {compiled['completeness']}")
+
+#         # STAGE 4: Farmer Translation
+#         if verbose:
+#             print("🌾 Stage 4: Generating advice...")
+        
+#         farmer_advice = self.translator.translate(query, compiled, self.location)
+
+#         pipeline_time = time.time() - pipeline_start
+
+#         if verbose:
+#             print(f"✅ Complete! Total: {pipeline_time:.2f}s\n")
+
+#         return {
+#             "query": query,
+#             "routing": routing,
+#             "compiled_data": compiled,
+#             "advice": farmer_advice,
+#             "pipeline_time_seconds": round(pipeline_time, 2)
+#         }
+
+"""
+Farmer.chat Pipeline - Main Orchestrator
+Coordinates Router → Executor → Compiler stages for alert generation
+"""
+
+from typing import Dict, Any, Optional
+from .router import QueryRouter
+from .executor import MCPExecutor
+from .compiler import ResponseCompiler
+
+
+class FarmerChatPipeline:
+    """
+    Main pipeline orchestrating the complete alert generation workflow.
+    
+    Architecture:
+    Stage 1: QueryRouter - Determines which MCP servers to query with priorities
+    Stage 2: MCPExecutor - Executes parallel calls to selected MCP servers
+    Stage 3: ResponseCompiler - Compiles results into actionable alert summary
+    """
+    
+    def __init__(self, servers: Dict[str, Any], location: Dict[str, float]):
+        """
+        Initialize pipeline with MCP servers and default location.
+        
+        Args:
+            servers: Dict mapping server names to initialized server instances
+            location: Default location dict with 'latitude' and 'longitude' keys
+        """
+        self.servers = servers
+        self.location = location
+        
+        # Initialize pipeline stages
+        self.router = QueryRouter()
+        self.executor = MCPExecutor(servers)
+        self.compiler = ResponseCompiler()
+        
+        print(f"✓ Pipeline initialized for location: {location['latitude']:.4f}°N, {location['longitude']:.4f}°E")
+    
+    def generate_alert(
+        self, 
+        location: Optional[Dict[str, float]] = None,
+        location_name: str = ""
+    ) -> Dict[str, Any]:
+        """
+        Generate comprehensive alert summary for a location.
+        
+        Always queries ALL MCP servers. The compiler extracts only
+        the alerting/concerning information from the comprehensive data.
+        
+        Args:
+            location: Optional location override. Uses default if not provided.
+            location_name: Human-readable location name for context
+            
+        Returns:
+            Dict containing:
+                - alert_summary: Compiled alert text (only concerning info)
+                - location: Location coordinates used
+                - mcp_results: Raw results from each MCP server
+        """
+        
+        # Use provided location or default
+        query_location = location or self.location
+        
+        print(f"\n{'='*60}")
+        print(f"Generating Alert Summary for {location_name or 'Location'}")
+        print(f"Coordinates: {query_location['latitude']:.4f}°N, {query_location['longitude']:.4f}°E")
+        print(f"{'='*60}\n")
+        
+        # Stage 1: Route - Always query all servers for alerts
+        print("Stage 1: Routing to all MCP servers...")
+        routing = self.router.route_alert_query(query_location)
+        print(f"✓ Routing complete: All 5 servers will be queried")
+        
+        # Stage 2: Execute - Query all MCP servers in parallel
+        print("\nStage 2: Executing parallel MCP server calls...")
+        mcp_results = self.executor.execute_parallel(routing, query_location)
+        
+        success_count = sum(1 for r in mcp_results.values() if r.get("status") == "success")
+        print(f"✓ Execution complete: {success_count}/{len(mcp_results)} servers responded successfully")
+        
+        # Stage 3: Compile - Extract ONLY alerting information
+        print("\nStage 3: Compiling alert summary (extracting concerning info only)...")
+        alert_summary = self.compiler.compile_alert_summary(
+            mcp_results, 
+            query_location,
+            location_name
+        )
+        print("✓ Alert summary generated (focusing on alerts/concerns only)")
+        
+        print(f"\n{'='*60}\n")
+        
+        return {
+            "alert_summary": alert_summary,
+            "location": query_location,
+            "location_name": location_name,
+            "mcp_results": mcp_results
+        }
+    
+    def process_query(
+        self, 
+        query: str, 
+        location: Optional[Dict[str, float]] = None
+    ) -> Dict[str, Any]:
+        """
+        Process a specific farmer query through the pipeline.
+        
+        For now, also queries all servers to ensure comprehensive data.
+        The compiler extracts query-relevant information.
+        
+        Args:
+            query: Farmer's question or request
+            location: Optional location override
+            
+        Returns:
+            Dict containing:
+                - response: Compiled response text
+                - location: Location coordinates used
+                - mcp_results: Raw results from MCP servers
+        """
+        
+        # Use provided location or default
+        query_location = location or self.location
+        
+        print(f"\n{'='*60}")
+        print(f"Processing Query: {query}")
+        print(f"Location: {query_location['latitude']:.4f}°N, {query_location['longitude']:.4f}°E")
+        print(f"{'='*60}\n")
+        
+        # Stage 1: Route - For now, query all servers
+        print("Stage 1: Routing to all MCP servers...")
+        routing = self.router.route_query(query, query_location)
+        print(f"✓ Routing complete: All servers will be queried")
+        
+        # Stage 2: Execute MCP calls
+        print("\nStage 2: Executing MCP server calls...")
+        mcp_results = self.executor.execute_parallel(routing, query_location)
+        
+        success_count = sum(1 for r in mcp_results.values() if r.get("status") == "success")
+        print(f"✓ Execution complete: {success_count}/{len(mcp_results)} servers responded")
+        
+        # Stage 3: Compile response
+        print("\nStage 3: Compiling response...")
+        response = self.compiler.compile_response(query, mcp_results, query_location)
+        print("✓ Response compiled")
+        
+        print(f"\n{'='*60}\n")
+        
+        return {
+            "response": response,
+            "location": query_location,
+            "mcp_results": mcp_results
+        }
+    
+    def update_location(self, location: Dict[str, float]):
+        """
+        Update default location for pipeline.
+        
+        Args:
+            location: New default location dict with 'latitude' and 'longitude' keys
+        """
+        self.location = location
+        print(f"✓ Default location updated to: {location['latitude']:.4f}°N, {location['longitude']:.4f}°E")
+    
+    def get_server_status(self) -> Dict[str, str]:
+        """
+        Get status of all MCP servers.
+        
+        Returns:
+            Dict mapping server names to "available" or "unavailable"
+        """
+        status = {}
+        for server_name, server in self.servers.items():
+            try:
+                # Try to check if server is responsive
+                if hasattr(server, 'health_check'):
+                    status[server_name] = "available" if server.health_check() else "unavailable"
+                else:
+                    status[server_name] = "available"  # Assume available if no health check
+            except:
+                status[server_name] = "unavailable"
+        
+        return status

src/router.py

@@ -0,0 +1,194 @@
+# """
+# Stage 1: Query Router - Intelligent Server Selection
+# """
+
+# import json
+# from typing import Dict, Any
+# from openai import OpenAI
+
+
+# class QueryRouter:
+#     """Stage 1: Routes queries to appropriate MCP servers"""
+
+#     def __init__(self, client: OpenAI, registry: Dict[str, Any]):
+#         self.client = client
+#         self.registry = registry
+
+#     def route(self, query: str, location: Dict[str, Any]) -> Dict[str, Any]:
+#         """
+#         Analyze query and determine which MCP servers are needed
+        
+#         Returns:
+#             {
+#                 "intent": str,
+#                 "required_servers": List[str],
+#                 "reasoning": str
+#             }
+#         """
+#         # Create registry summary
+#         registry_text = "Available MCP Servers:\n"
+#         for server_id, info in self.registry.items():
+#             registry_text += f"\n{server_id}:\n"
+#             registry_text += f"  Description: {info['description']}\n"
+#             registry_text += f"  Use for: {', '.join(info['use_for'][:5])}\n"
+
+#         system_prompt = f"""You are a query router for Farmer.chat agricultural system.
+
+# Your task: Analyze the farmer's query and select which MCP servers are needed.
+
+# {registry_text}
+
+# Location: {location['name']} ({location['lat']}°N, {location['lon']}°E)
+
+# CRITICAL RULES:
+# 1. Select ALL servers that provide data relevant to answering the query completely
+# 2. Consider IMPLICIT needs - look for context clues in the query
+# 3. Keywords that trigger elevation: "elevation", "slope", "terrain", "my land", "my field", "drainage", "waterlogged", "frost risk", "wind exposure"
+# 4. For crop decisions: ALWAYS include soil_properties + water + weather (comprehensive assessment)
+# 5. For weather risk questions (wind, frost, flood): Include weather + elevation (terrain affects risk)
+# 6. For pest questions with weather context: Include pests + weather
+# 7. Be generous - better to have extra data than miss critical information
+# 8. When farmer mentions location characteristics (height, slope, elevation), ALWAYS include elevation
+
+# FEW-SHOT EXAMPLES:
+
+# Example 1:
+# Query: "Are strong winds expected at my land elevation?"
+# Required: ["weather", "elevation"]
+# Reasoning: Wind forecast from weather, but elevation affects wind exposure and risk. Farmer explicitly mentions elevation.
+
+# Example 2:
+# Query: "Should I plant rice today?"
+# Required: ["weather", "soil_properties", "water"]
+# Reasoning: Planting decisions need weather conditions, soil suitability, and water availability for comprehensive assessment.
+
+# Example 3:
+# Query: "Is there risk of frost tonight?"
+# Required: ["weather", "elevation"]
+# Reasoning: Frost risk depends on temperature from weather AND elevation (cold air sinks to lower areas).
+
+# Example 4:
+# Query: "What's my soil composition?"
+# Required: ["soil_properties"]
+# Reasoning: Direct soil query, only soil data needed. No implicit needs.
+
+# Example 5:
+# Query: "Can I grow tomatoes here?"
+# Required: ["soil_properties", "water", "weather"]
+# Reasoning: Crop suitability requires soil type, water availability, and climate conditions.
+
+# Example 6:
+# Query: "My field gets waterlogged after rain"
+# Required: ["elevation", "soil_properties", "weather"]
+# Reasoning: Waterlogging relates to drainage (elevation/slope), soil permeability, and rainfall patterns.
+
+# Example 7:
+# Query: "Should I spray pesticides now?"
+# Required: ["pests", "weather"]
+# Reasoning: Need to know pest presence AND weather conditions for optimal application timing.
+
+# Example 8:
+# Query: "How's the weather?"
+# Required: ["weather"]
+# Reasoning: Direct weather query, no implicit needs.
+
+# Example 9:
+# Query: "Give me complete farm status"
+# Required: ["weather", "soil_properties", "water", "elevation", "pests"]
+# Reasoning: Comprehensive assessment requires all available data sources.
+
+# Example 10:
+# Query: "Will it be too windy on my elevated farm?"
+# Required: ["weather", "elevation"]
+# Reasoning: Wind from weather, elevation affects exposure. "Elevated" is explicit context clue.
+
+# Response format (JSON only):
+# {{
+#   "intent": "brief description of farmer's need",
+#   "required_servers": ["server_id1", "server_id2"],
+#   "reasoning": "why these servers"
+# }}
+# """
+
+#         try:
+#             response = self.client.chat.completions.create(
+#                 model="gpt-4o",
+#                 messages=[
+#                     {"role": "system", "content": system_prompt},
+#                     {"role": "user", "content": query}
+#                 ],
+#                 temperature=0.3
+#             )
+
+#             result_text = response.choices[0].message.content.strip()
+#             result_text = result_text.replace("```json", "").replace("```", "").strip()
+
+#             routing_decision = json.loads(result_text)
+#             return routing_decision
+
+#         except Exception as e:
+#             print(f"❌ Routing error: {e}")
+#             # Fallback - include common servers
+#             return {
+#                 "intent": "general_inquiry",
+#                 "required_servers": ["weather", "soil_properties", "water"],
+#                 "reasoning": "Fallback routing due to error"
+#             }
+
+"""
+Query Router - Stage 1
+Simple router that always queries all MCP servers for alert generation.
+The intelligence is in the compiler, not the router.
+"""
+
+from typing import Dict, Any
+
+
+class QueryRouter:
+    """
+    Router for alert generation system.
+    
+    For alert generation, ALWAYS queries all MCP servers since we need
+    comprehensive data to identify potential issues. The compiler handles
+    the intelligence of extracting only alerting/concerning information.
+    """
+    
+    def __init__(self):
+        """Initialize router - no LLM needed for simple all-server routing"""
+        pass
+    
+    def route_alert_query(self, location: Dict[str, float]) -> Dict[str, bool]:
+        """
+        Route for alert generation - always query ALL servers.
+        
+        Args:
+            location: Dict with 'latitude' and 'longitude' keys
+            
+        Returns:
+            Dict with all servers set to True
+        """
+        return {
+            "weather": True,
+            "soil": True,
+            "water": True,
+            "elevation": True,
+            "pests": True
+        }
+    
+    def route_query(self, query: str, location: Dict[str, float]) -> Dict[str, bool]:
+        """
+        Route a general query - for now, also queries all servers.
+        
+        In the future, could use LLM to determine which servers are relevant
+        to the specific query. But for alert generation, we always want all data.
+        
+        Args:
+            query: User's query
+            location: Dict with 'latitude' and 'longitude' keys
+            
+        Returns:
+            Dict indicating which servers to query
+        """
+        # For now, query all servers for any query
+        # The compiler will extract relevant information
+        return self.route_alert_query(location)  

src/servers/__init__.py

@@ -0,0 +1,18 @@
+"""
+MCP Server Implementations
+"""
+
+# Import all server classes
+from .weather import WeatherServer
+from .soil import SoilPropertiesServer
+from .water import WaterServer
+from .elevation import ElevationServer
+from .pests import PestsServer
+
+__all__ = [
+    'WeatherServer',
+    'SoilPropertiesServer',
+    'WaterServer',
+    'ElevationServer',
+    'PestsServer'
+]

src/servers/elevation.py

@@ -0,0 +1,49 @@
+"""
+All MCP Server Implementations
+Deploy as: src/servers/__init__.py OR separate files
+
+Contains:
+- WeatherServer (Open-Meteo)
+- SoilPropertiesServer (SoilGrids)
+- WaterServer (GRACE)
+- ElevationServer (OpenElevation)
+- PestsServer (iNaturalist)
+"""
+
+import aiohttp
+import asyncio
+import os
+import xarray as xr
+import requests
+from datetime import datetime
+from typing import Dict, Any
+
+# ============================================================================
+# ELEVATION SERVER (OpenElevation)
+# ============================================================================
+
+class ElevationServer:
+    """OpenElevation API Server"""
+
+    async def get_data(self, lat: float, lon: float) -> Dict[str, Any]:
+        try:
+            url = "https://api.open-elevation.com/api/v1/lookup"
+            params = {"locations": f"{lat},{lon}"}
+
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        elevation_m = data["results"][0]["elevation"]
+                        return {
+                            "status": "success",
+                            "data": {
+                                "elevation_meters": elevation_m,
+                                "elevation_feet": round(elevation_m * 3.28084, 1),
+                                "data_source": "OpenElevation API"
+                            }
+                        }
+                    else:
+                        return {"status": "error", "error": f"HTTP {response.status}"}
+        except Exception as e:
+            return {"status": "error", "error": str(e)}

src/servers/pests.py

@@ -0,0 +1,68 @@
+"""
+All MCP Server Implementations
+Deploy as: src/servers/__init__.py OR separate files
+
+Contains:
+- WeatherServer (Open-Meteo)
+- SoilPropertiesServer (SoilGrids)
+- WaterServer (GRACE)
+- ElevationServer (OpenElevation)
+- PestsServer (iNaturalist)
+"""
+
+import aiohttp
+import asyncio
+import os
+import xarray as xr
+import requests
+from datetime import datetime
+from typing import Dict, Any
+
+# ============================================================================
+# PESTS SERVER (iNaturalist)
+# ============================================================================
+
+class PestsServer:
+    """iNaturalist Pest Observation Server"""
+
+    async def get_data(self, lat: float, lon: float) -> Dict[str, Any]:
+        try:
+            url = "https://api.inaturalist.org/v1/observations"
+            params = {
+                "lat": lat,
+                "lng": lon,
+                "radius": 50,  # 50km radius
+                "order": "desc",
+                "order_by": "observed_on",
+                "per_page": 20,
+                "quality_grade": "research",
+                "iconic_taxa": "Insecta"
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        observations = data.get("results", [])
+
+                        pest_summary = []
+                        for obs in observations[:10]:
+                            pest_summary.append({
+                                "species": obs.get("taxon", {}).get("name", "Unknown"),
+                                "common_name": obs.get("taxon", {}).get("preferred_common_name", "N/A"),
+                                "observed_on": obs.get("observed_on"),
+                                "distance_km": obs.get("distance", "N/A")
+                            })
+
+                        return {
+                            "status": "success",
+                            "data": {
+                                "recent_observations": pest_summary,
+                                "total_count": len(observations),
+                                "data_source": "iNaturalist Community Data"
+                            }
+                        }
+                    else:
+                        return {"status": "error", "error": f"HTTP {response.status}"}
+        except Exception as e:
+            return {"status": "error", "error": str(e)}

src/servers/soil.py

@@ -0,0 +1,109 @@
+"""Soil Properties Server using Google Earth Engine with lazy initialization"""
+
+import ee
+import os
+import json
+from typing import Dict, Any
+
+
+class SoilPropertiesServer:
+    """Google Earth Engine Soil Server with lazy initialization"""
+    
+    def __init__(self):
+        """Initialize server (GEE will be initialized on first use)"""
+        self._gee_initialized = False
+        
+        self.layers = {
+            "clay": "OpenLandMap/SOL/SOL_CLAY-WFRACTION_USDA-3A1A1A_M/v02",
+            "sand": "OpenLandMap/SOL/SOL_SAND-WFRACTION_USDA-3A1A1A_M/v02",
+            "phh2o": "OpenLandMap/SOL/SOL_PH-H2O_USDA-4C1A2A_M/v02",
+            "soc": "OpenLandMap/SOL/SOL_ORGANIC-CARBON_USDA-6A1C_M/v02"
+        }
+        self.depth_band = "b0"
+    
+    def _initialize_gee(self):
+        """Initialize GEE lazily (only when first request is made)"""
+        if self._gee_initialized:
+            return
+        
+        try:
+            # Check if service account key is provided
+            service_account_key = os.environ.get('GEE_SERVICE_ACCOUNT_KEY')
+            
+            if service_account_key:
+                # Parse JSON key
+                credentials_dict = json.loads(service_account_key)
+                credentials = ee.ServiceAccountCredentials(
+                    credentials_dict['client_email'],
+                    key_data=service_account_key
+                )
+                ee.Initialize(credentials)
+                print("✅ GEE initialized with service account (lazy)")
+            else:
+                # Fallback to default credentials (for local development)
+                ee.Initialize(project='MCPprototypeGEE')
+                print("✅ GEE initialized with default credentials (lazy)")
+            
+            self._gee_initialized = True
+            
+        except Exception as e:
+            print(f"⚠️ GEE lazy initialization failed: {str(e)}")
+            raise
+    
+    async def get_data(self, lat: float, lon: float) -> Dict[str, Any]:
+        """Get soil properties at coordinate"""
+        
+        # Initialize GEE on first request (lazy loading)
+        if not self._gee_initialized:
+            self._initialize_gee()
+        
+        try:
+            point = ee.Geometry.Point([lon, lat])
+            results = {}
+            
+            for prop_name, image_id in self.layers.items():
+                try:
+                    image = ee.Image(image_id).select(self.depth_band)
+                    value = image.sample(point, 250).first().get(self.depth_band).getInfo()
+                    
+                    if value is not None:
+                        if prop_name in ['clay', 'sand']:
+                            results[prop_name] = round(value / 10, 1)
+                        elif prop_name == 'phh2o':
+                            results[prop_name] = round(value / 10, 1)
+                        elif prop_name == 'soc':
+                            results[prop_name] = round(value / 10, 1)
+                    else:
+                        results[prop_name] = None
+                except:
+                    results[prop_name] = None
+            
+            if not any(v is not None for v in results.values()):
+                return {
+                    "status": "error",
+                    "error": "No soil data available"
+                }
+            
+            silt = None
+            if results.get("clay") and results.get("sand"):
+                silt = round(100 - results["clay"] - results["sand"], 1)
+            
+            return {
+                "status": "success",
+                "data": {
+                    "clay_percent": results.get("clay"),
+                    "sand_percent": results.get("sand"),
+                    "silt_percent": silt,
+                    "pH": results.get("phh2o"),
+                    "organic_carbon_g_kg": results.get("soc"),
+                    "data_source": "Google Earth Engine (OpenLandMap)",
+                    "location": {"latitude": lat, "longitude": lon},
+                    "depth": "0-5cm"
+                }
+            }
+        
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e)
+            }

src/servers/water.py

@@ -0,0 +1,96 @@
+import aiohttp
+import asyncio
+import os
+import xarray as xr
+import requests
+from datetime import datetime
+from typing import Dict, Any
+
+# ============================================================================
+# WATER SERVER (GRACE Groundwater)
+# ============================================================================
+
+class WaterServer:
+    """GRACE Groundwater Server - Real NASA Data"""
+
+    async def get_data(self, lat: float, lon: float) -> Dict[str, Any]:
+        try:
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(None, self._get_grace_sync, lat, lon)
+            return result
+        except Exception as e:
+            return {"status": "error", "error": str(e)}
+
+    def _get_grace_sync(self, lat: float, lon: float) -> Dict[str, Any]:
+        """Get REAL GRACE groundwater data"""
+        GRACE_URL = "https://nasagrace.unl.edu/globaldata/current/GRACEDADM_CLSM025_GL_7D.nc4"
+        cache_dir = "./grace_cache"
+        os.makedirs(cache_dir, exist_ok=True)
+        cache_path = os.path.join(cache_dir, "grace_global_current.nc4")
+
+        try:
+            # Download if not cached
+            if not os.path.exists(cache_path):
+                response = requests.get(GRACE_URL, stream=True, timeout=120)
+                response.raise_for_status()
+                with open(cache_path, 'wb') as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        f.write(chunk)
+
+            # Open NetCDF dataset
+            ds = xr.open_dataset(cache_path)
+            point_data = ds.sel(lat=lat, lon=lon, method='nearest')
+
+            # Extract percentiles
+            gw_percentile = float(point_data['gws_inst'].values.item())
+            rtzsm_percentile = float(point_data['rtzsm_inst'].values.item())
+            sfsm_percentile = float(point_data['sfsm_inst'].values.item())
+
+            timestamp = str(point_data['time'].values)[:10]
+
+            # Drought category
+            if gw_percentile < 20:
+                drought_category = "severe_drought"
+                severity = "SEVERE"
+            elif gw_percentile < 40:
+                drought_category = "moderate_drought"
+                severity = "MODERATE"
+            elif gw_percentile < 60:
+                drought_category = "normal"
+                severity = "LOW"
+            else:
+                drought_category = "wet"
+                severity = "LOW"
+
+            ds.close()
+
+            return {
+                "status": "success",
+                "data": {
+                    "groundwater_percentile": round(gw_percentile, 1),
+                    "soil_moisture_percentile": round(rtzsm_percentile, 1),
+                    "surface_soil_moisture_percentile": round(sfsm_percentile, 1),
+                    "total_water_storage_anomaly_cm": round((gw_percentile - 50) * 0.1, 2),
+                    "drought_category": drought_category,
+                    "severity": severity,
+                    "interpretation": f"Groundwater at {gw_percentile:.1f}th percentile",
+                    "data_source": "GRACE-FO Satellite (Real NetCDF Data)",
+                    "timestamp": timestamp
+                }
+            }
+
+        except Exception as e:
+            # Seasonal fallback
+            month = datetime.now().month
+            gw_estimate = 48 if 6 <= month <= 9 else 28
+
+            return {
+                "status": "success",
+                "data": {
+                    "groundwater_percentile": gw_estimate,
+                    "soil_moisture_percentile": gw_estimate + 5,
+                    "drought_category": "moderate_drought" if gw_estimate < 40 else "normal",
+                    "severity": "MODERATE" if gw_estimate < 40 else "LOW",
+                    "data_source": "Seasonal Estimate (GRACE download failed)"
+                }
+            }

src/servers/weather.py

@@ -0,0 +1,52 @@
+import aiohttp
+import asyncio
+import os
+import xarray as xr
+import requests
+from datetime import datetime
+from typing import Dict, Any
+
+
+# ============================================================================
+# WEATHER SERVER (Open-Meteo)
+# ============================================================================
+
+class WeatherServer:
+    """Open-Meteo Weather API Server"""
+
+    async def get_data(self, lat: float, lon: float) -> Dict[str, Any]:
+        try:
+            url = "https://api.open-meteo.com/v1/forecast"
+            params = {
+                "latitude": lat,
+                "longitude": lon,
+                "current": "temperature_2m,precipitation,wind_speed_10m,relative_humidity_2m",
+                "daily": "temperature_2m_max,temperature_2m_min,precipitation_sum,rain_sum",
+                "timezone": "Asia/Kolkata",
+                "forecast_days": 7
+            }
+
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, params=params, timeout=aiohttp.ClientTimeout(total=10)) as response:
+                    if response.status == 200:
+                        data = await response.json()
+                        return {
+                            "status": "success",
+                            "data": {
+                                "current_temp_c": data["current"]["temperature_2m"],
+                                "current_precipitation_mm": data["current"]["precipitation"],
+                                "wind_speed_kmh": data["current"]["wind_speed_10m"],
+                                "humidity_percent": data["current"]["relative_humidity_2m"],
+                                "forecast_7day": {
+                                    "max_temps": data["daily"]["temperature_2m_max"],
+                                    "min_temps": data["daily"]["temperature_2m_min"],
+                                    "precipitation_mm": data["daily"]["precipitation_sum"],
+                                    "rain_mm": data["daily"]["rain_sum"]
+                                },
+                                "data_source": "Open-Meteo API"
+                            }
+                        }
+                    else:
+                        return {"status": "error", "error": f"HTTP {response.status}"}
+        except Exception as e:
+            return {"status": "error", "error": str(e)}

src/translator.py

@@ -0,0 +1,64 @@
+"""
+Stage 4: Farmer Translator - Natural Language Output
+"""
+
+import json
+from typing import Dict, Any
+from openai import OpenAI
+
+
+class FarmerTranslator:
+    """Stage 4: Convert technical data to farmer-friendly advice"""
+
+    def __init__(self, client: OpenAI):
+        self.client = client
+
+    def translate(self, query: str, compiled_data: Dict[str, Any], location: Dict[str, Any]) -> str:
+        """
+        Generate farmer-friendly response from technical data
+        
+        Returns:
+            str: Natural language advice for farmers
+        """
+        data_summary = json.dumps(compiled_data.get("data", {}), indent=2)
+
+        system_prompt = f"""You are an agricultural advisor for farmers in {location['name']}.
+
+Task: Convert technical data into clear, actionable advice.
+
+Guidelines:
+1. Use simple language (avoid jargon)
+2. Provide specific, actionable recommendations
+3. Include risk levels (LOW/MODERATE/HIGH) when relevant
+4. Explain WHY you're making recommendations
+5. If data is missing, acknowledge it but provide useful advice
+
+Structure:
+- Clear summary
+- Current conditions
+- Risk assessment (if applicable)
+- Specific recommendations
+- Action items
+
+Data from {len(compiled_data.get('successful_servers', []))} sources:
+{data_summary}
+"""
+
+        if compiled_data.get("failed_servers"):
+            system_prompt += f"\n\nNote: Some sources failed: {compiled_data['failed_servers']}"
+            system_prompt += "\nWork with available data, note limitations."
+
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-4o",
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"Farmer query: {query}\n\nProvide advice based on the data."}
+                ],
+                temperature=0.7
+            )
+
+            return response.choices[0].message.content
+
+        except Exception as e:
+            return f"⚠️ Unable to generate advice: {str(e)}"