Add 899999999999999

app.py

@@ -1,3 +1,23 @@
+from fastapi import FastAPI, Request
+from fastapi.responses import FileResponse, JSONResponse
+from evidence_pack_export import export_evidence_pack_pdf, export_evidence_pack_csv
+
+app = FastAPI()
+
+# ...existing code...
+
+@app.post("/export_evidence_pack")
+async def export_evidence_pack(request: Request):
+    data = await request.json()
+    format = data.get("format", "pdf")
+    if format == "pdf":
+        file_path = export_evidence_pack_pdf(data)
+        return FileResponse(file_path, media_type="application/pdf", filename="evidence_pack.pdf")
+    elif format == "csv":
+        file_path = export_evidence_pack_csv(data)
+        return FileResponse(file_path, media_type="text/csv", filename="evidence_pack.csv")
+    else:
+        return JSONResponse({"error": "Invalid format"}, status_code=400)
 import os
 import logging
 from datetime import datetime

enhanced_websocket_handler.py

@@ -422,27 +422,41 @@ async def get_hybrid_response(user_message: str, context: str, config: dict, kno
         from rag_service import search_documents_async
         docs = await search_documents_async(user_message, limit=3)
         if docs:
-            context = "\n\n".join([doc["content"] for doc in docs])
-            sources = [doc["source"] for doc in docs]
-            logger.info(f"📚 Found {len(docs)} documents from sources: {sources}")
+            from scenario_analysis_service import run_scenario_analysis
+            # Detect scenario analysis intent (simple keyword match)
+            scenario_keywords = ["impact", "cost", "scenario", "multiplier", "da", "dr"]
+            if any(kw in user_message.lower() for kw in scenario_keywords):
+                # Example params extraction (can be improved)
+                params = {
+                    'base_pension': 30000,
+                    'multiplier': 1.1 if "multiplier" in user_message.lower() else 1.0,
+                    'da_percent': 0.06 if "da" in user_message.lower() else 0.0,
+                    'num_beneficiaries': 1000,
+                    'years': 3,
+                    'inflation': 0.05
+                }
+                scenario_result = run_scenario_analysis(params)
+            else:
+                scenario_result = None
+            for doc in docs:
+                response_obj = {
+                    "clause_text": doc.get("clause_text", ""),
+                    "summary": doc.get("summary", ""),
+                    "role_checklist": doc.get("role_checklist", []),
+                    "source_title": doc.get("source_title", ""),
+                    "clause_id": doc.get("clause_id", ""),
+                    "date": doc.get("date", ""),
+                    "url": doc.get("url", ""),
+                    "score": doc.get("score", 1.0),
+                    "scenario_analysis": scenario_result
+                }
+                yield response_obj
         else:
             logger.info("📚 No documents found, using existing context")
+            yield {"clause_text": context, "summary": "", "role_checklist": [], "source_title": "", "clause_id": "", "date": "", "url": "", "score": 1.0}
     except Exception as e:
         logger.warning(f"❌ Document search failed: {e}, using existing context")
-    logger.info(f"🤖 Getting LLM response (streaming)...")
-    response_chunks = []
-    async for chunk in hybrid_llm_service.get_streaming_response(
-        user_message,
-        context=context,
-        system_prompt="""You are a helpful government document assistant. Provide accurate, helpful responses based on the context provided. When appropriate, suggest additional resources or redirect users to relevant departments for more assistance."""
-    ):
-        response_chunks.append(chunk)
-        yield chunk  # Yield each chunk for streaming to frontend
-    full_response = "".join(response_chunks)
-    logger.info(f"✅ LLM response received, length: {len(full_response)}")
-    provider = hybrid_llm_service.choose_llm_provider(user_message)
-    provider_used = provider.value if provider else "unknown"
-    return
+        yield {"clause_text": context, "summary": "", "role_checklist": [], "source_title": "", "clause_id": "", "date": "", "url": "", "score": 1.0}
 
 async def send_text_response(websocket: WebSocket, response_text: str, provider_used: str, session_data: dict):
     """Send text response to client"""

evidence_pack_export.py

@@ -0,0 +1,61 @@
+import csv
+from fpdf import FPDF
+import tempfile
+import os
+
+def export_evidence_pack_pdf(data, filename=None):
+    """
+    Export evidence pack as PDF. Data should include clause, summary, checklist, scenario, metadata.
+    Returns path to PDF file.
+    """
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    pdf.cell(200, 10, txt="Evidence Pack", ln=True, align='C')
+    pdf.ln(10)
+    pdf.set_font("Arial", size=10)
+    pdf.multi_cell(0, 8, f"Clause: {data.get('clause_text','')}")
+    pdf.multi_cell(0, 8, f"Summary: {data.get('summary','')}")
+    pdf.multi_cell(0, 8, f"Checklist: {', '.join(data.get('role_checklist',[]))}")
+    pdf.multi_cell(0, 8, f"Source: {data.get('source_title','')} | Clause ID: {data.get('clause_id','')} | Date: {data.get('date','')} | URL: {data.get('url','')}")
+    pdf.ln(5)
+    scenario = data.get('scenario_analysis',{})
+    if scenario:
+        pdf.multi_cell(0, 8, f"Scenario Analysis:")
+        pdf.multi_cell(0, 8, f"Yearly Results: {scenario.get('yearly_results','')}")
+        pdf.multi_cell(0, 8, f"Cumulative Base: {scenario.get('cumulative_base','')}")
+        pdf.multi_cell(0, 8, f"Cumulative Scenario: {scenario.get('cumulative_scenario','')}")
+        pdf.multi_cell(0, 8, f"Optimistic: {scenario.get('optimistic','')}")
+        pdf.multi_cell(0, 8, f"Pessimistic: {scenario.get('pessimistic','')}")
+        pdf.multi_cell(0, 8, f"Driver Breakdown: {scenario.get('driver_breakdown','')}")
+    if not filename:
+        filename = os.path.join(tempfile.gettempdir(), f"evidence_pack_{os.getpid()}.pdf")
+    pdf.output(filename)
+    return filename
+
+def export_evidence_pack_csv(data, filename=None):
+    """
+    Export evidence pack as CSV. Data should include clause, summary, checklist, scenario, metadata.
+    Returns path to CSV file.
+    """
+    if not filename:
+        filename = os.path.join(tempfile.gettempdir(), f"evidence_pack_{os.getpid()}.csv")
+    with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
+        writer = csv.writer(csvfile)
+        writer.writerow(["Field", "Value"])
+        writer.writerow(["Clause", data.get('clause_text','')])
+        writer.writerow(["Summary", data.get('summary','')])
+        writer.writerow(["Checklist", ', '.join(data.get('role_checklist',[]))])
+        writer.writerow(["Source", data.get('source_title','')])
+        writer.writerow(["Clause ID", data.get('clause_id','')])
+        writer.writerow(["Date", data.get('date','')])
+        writer.writerow(["URL", data.get('url','')])
+        scenario = data.get('scenario_analysis',{})
+        if scenario:
+            writer.writerow(["Yearly Results", scenario.get('yearly_results','')])
+            writer.writerow(["Cumulative Base", scenario.get('cumulative_base','')])
+            writer.writerow(["Cumulative Scenario", scenario.get('cumulative_scenario','')])
+            writer.writerow(["Optimistic", scenario.get('optimistic','')])
+            writer.writerow(["Pessimistic", scenario.get('pessimistic','')])
+            writer.writerow(["Driver Breakdown", scenario.get('driver_breakdown','')])
+    return filename

rag_service.py

@@ -149,9 +149,42 @@ async def search_documents_async(query: str, limit: int = 5) -> List[Dict[str, A
         all_docs = sorted(all_docs, key=lambda x: getattr(x, 'score', 1.0), reverse=True)[:limit]
         results = []
         for doc in all_docs:
+            metadata = doc.metadata if hasattr(doc, 'metadata') else {}
+            clause_text = doc.page_content
+            # Simple extractive summary: first sentence or up to 2 lines
+            summary = clause_text.split(". ")[0][:180] + ("..." if len(clause_text) > 180 else "")
+            # Role-aware checklist logic (basic template)
+            role_checklist = []
+            query_lower = query.lower()
+            if "pension" in query_lower:
+                role_checklist = [
+                    "Check eligibility (service years, misconduct)",
+                    "Collect required documents (service book, ID, proof)",
+                    "Obtain approvals (sanctioning authority)",
+                    "Submit application to pension office"
+                ]
+            elif "procurement" in query_lower or "bid" in query_lower:
+                role_checklist = [
+                    "Review procurement thresholds and MSME relaxations",
+                    "Prepare bid documents",
+                    "Complete registration and approvals",
+                    "Submit bid before deadline"
+                ]
+            elif "finance" in query_lower:
+                role_checklist = [
+                    "Check sanctioning steps",
+                    "Update registers",
+                    "Obtain necessary approvals",
+                    "Notify stakeholders"
+                ]
             results.append({
-                "content": doc.page_content,
-                "source": doc.metadata.get('source', 'Unknown'),
+                "clause_text": clause_text,
+                "summary": summary,
+                "role_checklist": role_checklist,
+                "source_title": metadata.get('title', metadata.get('source', 'Unknown')),
+                "clause_id": metadata.get('clause_id', ''),
+                "date": metadata.get('date', ''),
+                "url": metadata.get('url', ''),
                 "score": getattr(doc, 'score', 1.0)
             })
         logger.info(f"📚 Found {len(results)} documents for query: {query}")
@@ -184,9 +217,39 @@ async def search_rajasthan_documents_async(query: str, limit: int = 5) -> List[D
             return get_fallback_content(query)
         results = []
         for _, row in search_results.iterrows():
+            clause_text = row['content']
+            summary = clause_text.split(". ")[0][:180] + ("..." if len(clause_text) > 180 else "")
+            role_checklist = []
+            query_lower = query.lower()
+            if "pension" in query_lower:
+                role_checklist = [
+                    "Check eligibility (service years, misconduct)",
+                    "Collect required documents (service book, ID, proof)",
+                    "Obtain approvals (sanctioning authority)",
+                    "Submit application to pension office"
+                ]
+            elif "procurement" in query_lower or "bid" in query_lower:
+                role_checklist = [
+                    "Review procurement thresholds and MSME relaxations",
+                    "Prepare bid documents",
+                    "Complete registration and approvals",
+                    "Submit bid before deadline"
+                ]
+            elif "finance" in query_lower:
+                role_checklist = [
+                    "Check sanctioning steps",
+                    "Update registers",
+                    "Obtain necessary approvals",
+                    "Notify stakeholders"
+                ]
             results.append({
-                "content": row['content'],
-                "source": row['filename'],
+                "clause_text": clause_text,
+                "summary": summary,
+                "role_checklist": role_checklist,
+                "source_title": row.get('title', row.get('filename', 'Unknown')),
+                "clause_id": row.get('clause_id', ''),
+                "date": row.get('date', ''),
+                "url": row.get('url', ''),
                 "score": float(row.get('_distance', 1.0))
             })
         logger.info(f"📚 Found {len(results)} Rajasthan documents for query: {query}")

scenario_analysis_service.py

@@ -1,3 +1,61 @@
+import math
+import datetime
+from typing import Dict, Any
+
+def run_scenario_analysis(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Simulate scenario impact for pension/DA/DR changes.
+    params: {
+        'base_pension': float,
+        'multiplier': float,
+        'da_percent': float,
+        'num_beneficiaries': int,
+        'years': int,
+        'inflation': float
+    }
+    Returns: dict with yearly/cumulative cost, sensitivity bands, driver breakdown
+    """
+    base_pension = params.get('base_pension', 30000)
+    multiplier = params.get('multiplier', 1.0)
+    da_percent = params.get('da_percent', 0.06)
+    num_beneficiaries = params.get('num_beneficiaries', 1000)
+    years = params.get('years', 3)
+    inflation = params.get('inflation', 0.05)
+
+    results = []
+    total_base = 0
+    total_scenario = 0
+    for year in range(1, years+1):
+        # Baseline
+        base_cost = base_pension * num_beneficiaries * ((1+inflation)**(year-1))
+        # Scenario: multiplier and DA applied
+        scenario_cost = base_pension * multiplier * (1+da_percent) * num_beneficiaries * ((1+inflation)**(year-1))
+        results.append({
+            'year': year,
+            'base_cost': round(base_cost,2),
+            'scenario_cost': round(scenario_cost,2)
+        })
+        total_base += base_cost
+        total_scenario += scenario_cost
+
+    # Sensitivity bands (simple optimistic/pessimistic)
+    optimistic = total_scenario * 0.95
+    pessimistic = total_scenario * 1.10
+    driver_breakdown = {
+        'beneficiaries': round(num_beneficiaries * base_pension * multiplier * years,2),
+        'rate_change': round(base_pension * (multiplier-1) * num_beneficiaries * years,2),
+        'da_increase': round(base_pension * da_percent * num_beneficiaries * years,2)
+    }
+
+    return {
+        'yearly_results': results,
+        'cumulative_base': round(total_base,2),
+        'cumulative_scenario': round(total_scenario,2),
+        'optimistic': round(optimistic,2),
+        'pessimistic': round(pessimistic,2),
+        'driver_breakdown': driver_breakdown,
+        'timestamp': datetime.datetime.now().isoformat()
+    }
 import matplotlib.pyplot as plt
 import seaborn as sns
 import plotly.graph_objects as go