Cleanup and Fixes

.streamlit/config.toml

@@ -0,0 +1,9 @@
+[theme]
+primaryColor = "#1A73E8"
+backgroundColor = "#FFFFFF"
+secondaryBackgroundColor = "#F8F9FA"
+textColor = "#202124"
+font = "sans serif"
+
+[server]
+headless = true

API_DOCUMENTATION.md

@@ -0,0 +1,658 @@
+# Jan-Contract Enhanced API Documentation
+
+## Overview
+
+The Jan-Contract Enhanced API provides comprehensive services for India's informal workforce, including contract generation, scheme discovery, document analysis, and AI-powered assistance.
+
+**Base URL:** `http://localhost:8000`  
+**API Version:** 2.1.0  
+**Documentation:** `/docs` (Swagger UI) or `/redoc` (ReDoc)
+
+---
+
+## Table of Contents
+
+1. [Authentication & Setup](#authentication--setup)
+2. [Contract Generator API](#contract-generator-api)
+3. [Scheme Finder API](#scheme-finder-api)
+4. [PDF Demystifier API](#pdf-demystifier-api)
+5. [General Assistant API](#general-assistant-api)
+6. [Media Processing API](#media-processing-api)
+7. [System Endpoints](#system-endpoints)
+8. [Error Handling](#error-handling)
+9. [Testing Examples](#testing-examples)
+
+---
+
+## Authentication & Setup
+
+### Environment Variables Required
+
+```bash
+GOOGLE_API_KEY=your_google_api_key
+GROQ_API_KEY=your_groq_api_key
+TAVILY_API_KEY=your_tavily_api_key
+```
+
+### Health Check
+
+**Endpoint:** `GET /health`
+
+**Response:**
+```json
+{
+  "status": "healthy",
+  "version": "2.1.0",
+  "timestamp": "2024-01-15T10:30:00.000Z",
+  "services": {
+    "directories": {
+      "video_consents": true,
+      "pdfs_demystify": true
+    },
+    "modules": {
+      "streamlit_webrtc": "✅",
+      "av": "✅",
+      "speech_recognition": "✅"
+    },
+    "api_keys": {
+      "GOOGLE_API_KEY": "✅",
+      "GROQ_API_KEY": "✅",
+      "TAVILY_API_KEY": "✅"
+    }
+  }
+}
+```
+
+---
+
+## Contract Generator API
+
+### 1. Generate Contract
+
+**Endpoint:** `POST /api/v1/contracts/generate`
+
+**Description:** Generate a digital contract from plain text description.
+
+**Request Payload:**
+```json
+{
+  "user_request": "I need a contract for hiring a domestic helper for 6 months with weekly payment of Rs. 3000"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Contract generated successfully",
+  "data": {
+    "contract_id": "123e4567-e89b-12d3-a456-426614174000",
+    "contract": "DOMESTIC HELPER EMPLOYMENT AGREEMENT\n\nThis agreement is made between...",
+    "legal_trivia": {
+      "trivia": [
+        {
+          "point": "Minimum wage rights for domestic workers",
+          "explanation": "Domestic workers are entitled to minimum wages as per state regulations",
+          "source_url": "https://labour.gov.in/sites/default/files/domestic_workers_act.pdf"
+        }
+      ]
+    },
+    "created_at": "2024-01-15T10:30:00.000Z"
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+### 2. Generate Contract PDF
+
+**Endpoint:** `POST /api/v1/contracts/generate-pdf`
+
+**Description:** Generate a contract and return it as a downloadable PDF file.
+
+**Request Payload:**
+```json
+{
+  "user_request": "I need a contract for hiring a domestic helper for 6 months with weekly payment of Rs. 3000"
+}
+```
+
+**Response:** PDF file download with headers:
+```
+Content-Type: application/pdf
+Content-Disposition: attachment;filename=contract_20240115_103000.pdf
+```
+
+### 3. Get Contract
+
+**Endpoint:** `GET /api/v1/contracts/{contract_id}`
+
+**Description:** Retrieve a previously generated contract by ID.
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Contract retrieved successfully",
+  "data": {
+    "legal_doc": "DOMESTIC HELPER EMPLOYMENT AGREEMENT\n\nThis agreement is made between...",
+    "legal_trivia": {
+      "trivia": [...]
+    },
+    "created_at": "2024-01-15T10:30:00.000Z",
+    "user_request": "I need a contract for hiring a domestic helper..."
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+### 4. List Contracts
+
+**Endpoint:** `GET /api/v1/contracts`
+
+**Description:** List all generated contracts with summaries.
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Found 2 contract(s)",
+  "data": {
+    "contracts": [
+      {
+        "id": "123e4567-e89b-12d3-a456-426614174000",
+        "summary": "DOMESTIC HELPER EMPLOYMENT AGREEMENT\n\nThis agreement is made between...",
+        "created_at": "2024-01-15T10:30:00.000Z",
+        "user_request": "I need a contract for hiring a domestic helper for 6 months..."
+      }
+    ]
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+### 5. Delete Contract
+
+**Endpoint:** `DELETE /api/v1/contracts/{contract_id}`
+
+**Description:** Delete a specific contract and its associated data.
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Contract and associated data deleted successfully",
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+---
+
+## Scheme Finder API
+
+### Find Government Schemes
+
+**Endpoint:** `POST /api/v1/schemes/find`
+
+**Description:** Find relevant government schemes based on user profile.
+
+**Request Payload:**
+```json
+{
+  "user_profile": "I am a 35-year-old woman from rural Maharashtra, working as a daily wage laborer, looking for financial assistance schemes"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Schemes found successfully",
+  "data": {
+    "schemes": [
+      {
+        "scheme_name": "Pradhan Mantri Jan Dhan Yojana",
+        "description": "Financial inclusion program providing basic banking services to unbanked households",
+        "target_audience": "Unbanked households, especially women",
+        "official_link": "https://pmjdy.gov.in/"
+      },
+      {
+        "scheme_name": "Mahila Shakti Kendra",
+        "description": "Women empowerment scheme providing support for rural women",
+        "target_audience": "Rural women",
+        "official_link": "https://wcd.nic.in/schemes/mahila-shakti-kendra"
+      }
+    ]
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+---
+
+## PDF Demystifier API
+
+### 1. Upload Document
+
+**Endpoint:** `POST /api/v1/demystify/upload`
+
+**Description:** Upload a PDF document for AI-powered analysis.
+
+**Request:** Multipart form data
+- `file`: PDF file (max 50MB)
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Document uploaded and analyzed successfully",
+  "data": {
+    "session_id": "456e7890-e89b-12d3-a456-426614174001",
+    "report": {
+      "summary": "This is a rental agreement for a residential property...",
+      "key_terms": [
+        {
+          "term": "Security Deposit",
+          "explanation": "A refundable amount paid by tenant to cover potential damages",
+          "resource_link": "https://housing.com/guides/security-deposit"
+        }
+      ],
+      "overall_advice": "This is an automated analysis. For critical matters, please consult with a qualified legal professional."
+    },
+    "filename": "rental_agreement.pdf",
+    "upload_time": "2024-01-15T10:30:00.000Z"
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+### 2. Chat with Document
+
+**Endpoint:** `POST /api/v1/demystify/chat`
+
+**Description:** Ask follow-up questions about an uploaded document.
+
+**Request Payload:**
+```json
+{
+  "session_id": "456e7890-e89b-12d3-a456-426614174001",
+  "question": "What are the key terms I should be aware of in this contract?"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Question answered successfully",
+  "data": {
+    "answer": "Based on the document, the key terms you should be aware of include: 1. Security Deposit - A refundable amount...",
+    "session_id": "456e7890-e89b-12d3-a456-426614174001",
+    "question": "What are the key terms I should be aware of in this contract?"
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+### 3. List Sessions
+
+**Endpoint:** `GET /api/v1/demystify/sessions`
+
+**Description:** List all active document analysis sessions.
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Found 1 active session(s)",
+  "data": {
+    "sessions": [
+      {
+        "session_id": "456e7890-e89b-12d3-a456-426614174001",
+        "filename": "rental_agreement.pdf",
+        "upload_time": "2024-01-15T10:30:00.000Z"
+      }
+    ]
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+### 4. Delete Session
+
+**Endpoint:** `DELETE /api/v1/demystify/sessions/{session_id}`
+
+**Description:** Delete a document analysis session and its associated files.
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Session and associated files deleted successfully",
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+---
+
+## General Assistant API
+
+### Chat with AI Assistant
+
+**Endpoint:** `POST /api/v1/assistant/chat`
+
+**Description:** Get AI-powered assistance for general questions.
+
+**Request Payload:**
+```json
+{
+  "question": "What are my rights as a domestic worker in India?"
+}
+```
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Response generated successfully",
+  "data": {
+    "response": "As a domestic worker in India, you have several important rights: 1. Right to minimum wages as per state regulations...",
+    "question": "What are my rights as a domestic worker in India?"
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+---
+
+## Media Processing API
+
+### 1. Upload Video Consent
+
+**Endpoint:** `POST /api/v1/media/upload-video`
+
+**Description:** Upload a video consent file for a specific contract.
+
+**Request:** Multipart form data
+- `file`: Video file (MP4, AVI, MOV - max 100MB)
+- `contract_id`: Contract identifier
+- `consent_text`: Text of the consent being recorded
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Video consent uploaded successfully",
+  "data": {
+    "video_path": "video_consents/consent_123e4567-e89b-12d3-a456-426614174000_789.mp4",
+    "contract_id": "123e4567-e89b-12d3-a456-426614174000",
+    "filename": "consent_123e4567-e89b-12d3-a456-426614174000_789.mp4",
+    "size": 2048576,
+    "consent_text": "I agree to the terms and conditions of this employment contract"
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+### 2. Get Contract Videos
+
+**Endpoint:** `GET /api/v1/media/videos/{contract_id}`
+
+**Description:** Get all video consents for a specific contract.
+
+**Response:**
+```json
+{
+  "success": true,
+  "message": "Found 1 video(s) for contract",
+  "data": {
+    "videos": [
+      {
+        "filename": "consent_123e4567-e89b-12d3-a456-426614174000_789.mp4",
+        "path": "video_consents/consent_123e4567-e89b-12d3-a456-426614174000_789.mp4",
+        "size": 2048576,
+        "created": "2024-01-15T10:30:00.000Z"
+      }
+    ]
+  },
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+---
+
+## System Endpoints
+
+### Root Endpoint
+
+**Endpoint:** `GET /`
+
+**Description:** API root endpoint with comprehensive information.
+
+**Response:**
+```json
+{
+  "message": "Jan-Contract Enhanced API",
+  "version": "2.1.0",
+  "description": "Comprehensive API for India's informal workforce",
+  "features": [
+    "Contract Generation",
+    "Scheme Discovery",
+    "Document Analysis",
+    "AI Assistant",
+    "Media Processing"
+  ],
+  "endpoints": {
+    "health": "/health",
+    "contracts": "/api/v1/contracts/generate",
+    "schemes": "/api/v1/schemes/find",
+    "demystify": "/api/v1/demystify/upload",
+    "assistant": "/api/v1/assistant/chat",
+    "media": "/api/v1/media/upload-video"
+  },
+  "docs": "/docs",
+  "redoc": "/redoc"
+}
+```
+
+---
+
+## Error Handling
+
+### Standard Error Response Format
+
+```json
+{
+  "success": false,
+  "message": "Request failed",
+  "error": "Detailed error message",
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+### Common HTTP Status Codes
+
+- `200 OK`: Request successful
+- `400 Bad Request`: Invalid request data
+- `404 Not Found`: Resource not found
+- `422 Unprocessable Entity`: Validation error
+- `500 Internal Server Error`: Server error
+
+### Validation Errors
+
+```json
+{
+  "success": false,
+  "message": "Request failed",
+  "error": [
+    {
+      "loc": ["body", "user_request"],
+      "msg": "ensure this value has at least 10 characters",
+      "type": "value_error.any_str.min_length"
+    }
+  ],
+  "timestamp": "2024-01-15T10:30:00.000Z"
+}
+```
+
+---
+
+## Testing Examples
+
+### Using cURL
+
+#### 1. Generate Contract
+```bash
+curl -X POST "http://localhost:8000/api/v1/contracts/generate" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_request": "I need a contract for hiring a domestic helper for 6 months with weekly payment of Rs. 3000"
+  }'
+```
+
+#### 2. Find Schemes
+```bash
+curl -X POST "http://localhost:8000/api/v1/schemes/find" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "user_profile": "I am a 35-year-old woman from rural Maharashtra, working as a daily wage laborer, looking for financial assistance schemes"
+  }'
+```
+
+#### 3. Upload Document
+```bash
+curl -X POST "http://localhost:8000/api/v1/demystify/upload" \
+  -F "file=@/path/to/document.pdf"
+```
+
+#### 4. Chat with Assistant
+```bash
+curl -X POST "http://localhost:8000/api/v1/assistant/chat" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "question": "What are my rights as a domestic worker in India?"
+  }'
+```
+
+### Using Python requests
+
+```python
+import requests
+import json
+
+# Base URL
+BASE_URL = "http://localhost:8000"
+
+# 1. Generate Contract
+contract_data = {
+    "user_request": "I need a contract for hiring a domestic helper for 6 months with weekly payment of Rs. 3000"
+}
+response = requests.post(f"{BASE_URL}/api/v1/contracts/generate", json=contract_data)
+print(response.json())
+
+# 2. Find Schemes
+scheme_data = {
+    "user_profile": "I am a 35-year-old woman from rural Maharashtra, working as a daily wage laborer, looking for financial assistance schemes"
+}
+response = requests.post(f"{BASE_URL}/api/v1/schemes/find", json=scheme_data)
+print(response.json())
+
+# 3. Chat with Assistant
+chat_data = {
+    "question": "What are my rights as a domestic worker in India?"
+}
+response = requests.post(f"{BASE_URL}/api/v1/assistant/chat", json=chat_data)
+print(response.json())
+
+# 4. Upload Document
+with open("document.pdf", "rb") as f:
+    files = {"file": f}
+    response = requests.post(f"{BASE_URL}/api/v1/demystify/upload", files=files)
+    print(response.json())
+```
+
+### Using JavaScript/Fetch
+
+```javascript
+const BASE_URL = "http://localhost:8000";
+
+// 1. Generate Contract
+async function generateContract() {
+  const response = await fetch(`${BASE_URL}/api/v1/contracts/generate`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      user_request: "I need a contract for hiring a domestic helper for 6 months with weekly payment of Rs. 3000"
+    })
+  });
+  const data = await response.json();
+  console.log(data);
+}
+
+// 2. Find Schemes
+async function findSchemes() {
+  const response = await fetch(`${BASE_URL}/api/v1/schemes/find`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      user_profile: "I am a 35-year-old woman from rural Maharashtra, working as a daily wage laborer, looking for financial assistance schemes"
+    })
+  });
+  const data = await response.json();
+  console.log(data);
+}
+
+// 3. Chat with Assistant
+async function chatWithAssistant() {
+  const response = await fetch(`${BASE_URL}/api/v1/assistant/chat`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      question: "What are my rights as a domestic worker in India?"
+    })
+  });
+  const data = await response.json();
+  console.log(data);
+}
+```
+
+---
+
+## Rate Limits & Best Practices
+
+### Rate Limits
+- No explicit rate limits implemented
+- Recommended: 100 requests per minute per IP
+- Large file uploads may take longer processing time
+
+### Best Practices
+1. **Always check the health endpoint** before making requests
+2. **Use appropriate content types** for different endpoints
+3. **Handle errors gracefully** with proper error checking
+4. **Store session IDs** for document chat functionality
+5. **Validate file sizes** before upload (50MB for PDFs, 100MB for videos)
+6. **Use HTTPS in production** for security
+
+### File Upload Guidelines
+- **PDF files**: Maximum 50MB, only PDF format
+- **Video files**: Maximum 100MB, formats: MP4, AVI, MOV
+- **File naming**: Avoid special characters, use alphanumeric names
+
+---
+
+## Support & Contact
+
+- **API Documentation**: `/docs` (Swagger UI)
+- **Alternative Docs**: `/redoc` (ReDoc)
+- **Health Check**: `/health`
+- **Support Email**: support@jan-contract.com
+- **Version**: 2.1.0
+
+---
+
+*This documentation is automatically generated and updated with each API version release.*

agents/demystifier_agent.py

@@ -6,16 +6,16 @@ from pydantic import BaseModel, Field
 
 # --- Core LangChain & Document Processing Imports ---
 from langchain_community.document_loaders import PyMuPDFLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_text_splitters import RecursiveCharacterTextSplitter
 from langchain_community.vectorstores import FAISS
-from langchain.prompts import PromptTemplate
-from langchain.schema.runnable import RunnablePassthrough
-from langchain.schema.output_parser import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.output_parsers import StrOutputParser
 
 # LangGraph Imports
 from langgraph.graph import StateGraph, END, START
 
-# --- Tool and NEW Core Model Loader Imports ---
+# --- Tool and Core Model Loader Imports ---
 from tools.legal_tools import legal_search
 from core_utils.core_model_loaders import load_groq_llm, load_embedding_model
 
@@ -24,7 +24,7 @@ from core_utils.core_model_loaders import load_groq_llm, load_embedding_model
 groq_llm = load_groq_llm()
 embedding_model = load_embedding_model()
 
-# --- Pydantic Models (No Changes) ---
+# --- Pydantic Models ---
 class ExplainedTerm(BaseModel):
     term: str = Field(description="The legal term or jargon identified.")
     explanation: str = Field(description="A simple, plain-English explanation of the term.")
@@ -35,7 +35,7 @@ class DemystifyReport(BaseModel):
     key_terms: List[ExplainedTerm] = Field(description="A list of the most important explained legal terms.")
     overall_advice: str = Field(description="A concluding sentence of general advice.")
 
-# --- 2. LangGraph for Document Analysis (No Changes) ---
+# --- 2. LangGraph for Document Analysis ---
 class DemystifyState(TypedDict):
     document_chunks: List[str]
     summary: str
@@ -45,43 +45,110 @@ class DemystifyState(TypedDict):
 def summarize_node(state: DemystifyState):
     """Takes all document chunks and creates a high-level summary."""
     print("---NODE (Demystify): Generating Summary---")
-    context = "\n\n".join(state["document_chunks"])
-    prompt = f"You are a paralegal expert... Document Content:\n{context}"
-    summary = groq_llm.invoke(prompt).content
+    chunks = state.get("document_chunks", [])
+    if not chunks:
+        return {"summary": "No content to summarize."}
+        
+    context = "\n\n".join(chunks)
+    prompt = f"You are a paralegal expert for the Indian legal system. Summarize the following document clearly for a layman:\n\n{context}"
+    try:
+        response = groq_llm.invoke(prompt)
+        summary = response.content if response and response.content else "Summary generation failed."
+    except Exception as e:
+        print(f"Summary generation error: {e}")
+        summary = "Summary generation failed due to an error."
+        
     return {"summary": summary}
 
 def identify_terms_node(state: DemystifyState):
     """Identifies the most critical and potentially confusing legal terms in the document."""
     print("---NODE (Demystify): Identifying Key Terms---")
-    context = "\n\n".join(state["document_chunks"])
-    prompt = f"Based on the following legal document, identify the 3-5 most critical legal terms... Document Content:\n{context}"
-    terms_string = groq_llm.invoke(prompt).content
-    identified_terms = [term.strip() for term in terms_string.split(',') if term.strip()]
-    return {"identified_terms": identified_terms}
+    try:
+        context = "\n\n".join(state.get("document_chunks", []))
+        if not context:
+            print("Warning: No document context found for term identification.")
+            return {"identified_terms": []}
+            
+        prompt = f"Identify the 3-5 most critical complex legal terms in the following document that a layman would not understand. Return only the terms separated by commas.\n\n{context}"
+        response = groq_llm.invoke(prompt)
+        
+        if not response or not response.content:
+            print("Warning: Empty response from LLM for term identification.")
+            return {"identified_terms": []}
+            
+        terms_string = response.content
+        identified_terms = [term.strip() for term in terms_string.split(',') if term.strip()]
+        return {"identified_terms": identified_terms}
+    except Exception as e:
+        print(f"Error in identify_terms_node: {e}")
+        return {"identified_terms": []}
 
 def generate_report_node(state: DemystifyState):
     """Combines the summary and terms into a final, structured report with enriched explanations."""
     print("---NODE (Demystify): Generating Final Report---")
     explained_terms_list = []
-    document_context = "\n\n".join(state["document_chunks"])
-    for term in state["identified_terms"]:
+    
+    # Handle None or empty document_chunks
+    chunks = state.get("document_chunks", [])
+    document_context = "\n\n".join(chunks) if chunks else ""
+    
+    # Handle None identified_terms
+    terms = state.get("identified_terms", [])
+    if terms is None:
+        terms = []
+        
+    for term in terms:
         print(f"  - Researching term: {term}")
-        search_results = legal_search.invoke(f"simple explanation of legal term '{term}' in Indian law")
-        prompt = f"""A user is reading a legal document that contains the term "{term}".
-        Overall document context is: {document_context[:2000]}
-        Web search results for "{term}" are: {search_results}
-        Format your response strictly as:
-        Explanation: [Your simple, one-sentence explanation here]
-        URL: [The best, full, working URL from the search results]"""
-        response = groq_llm.invoke(prompt).content
         try:
-            explanation = response.split("Explanation:")[1].split("URL:")[0].strip()
-            link = response.split("URL:")[-1].strip()
-        except IndexError:
-            explanation = "Could not generate a simple explanation for this term."
-            link = "No link found."
+            search_results = legal_search.invoke(f"simple explanation of legal term '{term}' in Indian law")
+        except Exception as e:
+            print(f"Search failed for term '{term}': {e}")
+            search_results = "Search unavailable."
+
+        prompt = f"""
+        A user is reading a legal document containing the term "{term}".
+        Context: {document_context[:2000]}...
+        Search Results: {search_results}
+        
+        Provide a simple one-sentence explanation and a valid URL if found.
+        Format:
+        Explanation: [Explanation]
+        URL: [URL]
+        """
+        try:
+            response = groq_llm.invoke(prompt)
+            if response and response.content:
+                content = response.content
+                try:
+                    if "Explanation:" in content and "URL:" in content:
+                        explanation = content.split("Explanation:")[1].split("URL:")[0].strip()
+                        link = content.split("URL:")[-1].strip()
+                    else:
+                        explanation = content.strip()
+                        link = "https://kanoon.nearlaw.com/"
+                except Exception:
+                    explanation = f"Legal term '{term}' identified."
+                    link = "https://kanoon.nearlaw.com/"
+            else:
+                 explanation = "Explanation unavailable."
+                 link = "https://kanoon.nearlaw.com/"
+        except Exception as e:
+            print(f"LLM failed for term '{term}': {e}")
+            explanation = "Explanation unavailable."
+            link = "https://kanoon.nearlaw.com/"
+            
         explained_terms_list.append(ExplainedTerm(term=term, explanation=explanation, resource_link=link))
-    final_report = DemystifyReport(summary=state["summary"], key_terms=explained_terms_list, overall_advice="This is an automated analysis. For critical matters, please consult with a qualified legal professional.")
+        
+    # Ensure summary is not None
+    summary_text = state.get("summary", "Summary unavailable.")
+    if summary_text is None:
+        summary_text = "Summary unavailable."
+
+    final_report = DemystifyReport(
+        summary=summary_text, 
+        key_terms=explained_terms_list, 
+        overall_advice="This AI analysis is for informational purposes only. Consult a lawyer for binding advice."
+    )
     return {"final_report": final_report}
 
 # Compile the analysis graph
@@ -95,29 +162,42 @@ graph_builder.add_edge("identify_terms", "generate_report")
 graph_builder.add_edge("generate_report", END)
 demystifier_agent_graph = graph_builder.compile()
 
-# --- 3. Helper Function to Create the RAG Chain (No Changes) ---
+# --- 3. Helper Function to Create the RAG Chain ---
 def create_rag_chain(retriever):
     """Creates the Q&A chain for the interactive chat."""
-    prompt_template = """You are a helpful assistant... CONTEXT: {context} QUESTION: {question} ANSWER:"""
+    prompt_template = """You are a helpful legal assistant. Answer based on the context only.
+    CONTEXT: {context} 
+    QUESTION: {question} 
+    ANSWER:"""
     prompt = PromptTemplate.from_template(prompt_template)
     rag_chain = ({"context": retriever, "question": RunnablePassthrough()} | prompt | groq_llm | StrOutputParser())
     return rag_chain
 
-# --- 4. The Master "Controller" Function (No Changes) ---
+# --- 4. The Master "Controller" Function ---
 def process_document_for_demystification(file_path: str):
     """Loads a PDF, runs the full analysis, creates a RAG chain, and returns both."""
     print(f"--- Processing document: {file_path} ---")
+    
     loader = PyMuPDFLoader(file_path)
     documents = loader.load()
+    
+    if not documents:
+        raise ValueError("No content found in PDF.")
+
     splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
     chunks = splitter.split_documents(documents)
+    
     print("--- Creating FAISS vector store for Q&A ---")
     vectorstore = FAISS.from_documents(chunks, embedding=embedding_model)
     retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
     rag_chain = create_rag_chain(retriever)
+    
     print("--- Running analysis graph for the report ---")
     chunk_contents = [chunk.page_content for chunk in chunks]
-    graph_input = {"document_chunks": chunk_contents}
+    # Limit context to avoid token limits if document is huge
+    graph_input = {"document_chunks": chunk_contents[:10]} 
+    
     result = demystifier_agent_graph.invoke(graph_input)
     report = result.get("final_report")
+    
     return {"report": report, "rag_chain": rag_chain}

agents/general_assistant_agent.py

@@ -1,27 +1,47 @@
-# D:\jan-contract\agents\general_assistant_agent.py
-
 import os
-import google.generativeai as genai
+import time
+import random
+from google import genai
+from google.genai import types
 
 # Configure the API key from the .env file
 try:
-    genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
-    # Use a specific, robust model name
-    model = genai.GenerativeModel('gemini-1.5-flash')
+    client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
+    model_name = "gemini-2.0-flash-exp" # Using the user's preferred model
 except Exception as e:
-    print(f"Error configuring Google Generative AI: {e}")
-    model = None
+    print(f"Error configuring Google Gen AI Client: {e}")
+    client = None
+    model_name = None
 
 def ask_gemini(prompt: str) -> str:
     """
-    Sends a prompt directly to the Google Gemini API and returns the text response.
-    This is the core logic from your script, adapted for our application.
+    Sends a prompt directly to the Google Gen AI API using the new SDK.
+    Includes robust retry logic for 429 Resource Exhausted errors.
     """
-    if model is None:
-        return "Error: The Generative AI model is not configured. Please check your API key."
+    if client is None:
+        return "Error: The Gen AI client is not configured. Please check your API key."
+    
+    max_retries = 5
+    base_delay = 2  # seconds
+
+    for attempt in range(max_retries):
+        try:
+            response = client.models.generate_content(
+                model=model_name,
+                contents=prompt
+            )
+            return response.text
+        except Exception as e:
+            error_str = str(e)
+            if "429" in error_str or "RESOURCE_EXHAUSTED" in error_str:
+                if attempt == max_retries - 1:
+                    return f"Error: Rate limit exceeded after {max_retries} attempts. Please try again later."
+                
+                # Exponential backoff with jitter
+                delay = (base_delay * (2 ** attempt)) + random.uniform(0, 1)
+                print(f"Rate limit hit. Retrying in {delay:.2f} seconds...")
+                time.sleep(delay)
+            else:
+                return f"An error occurred while communicating with the Gemini API: {str(e)}"
     
-    try:
-        response = model.generate_content(prompt)
-        return response.text
-    except Exception as e:
-        return f"An error occurred while communicating with the Gemini API: {str(e)}"
+    return "Error: Failed to get response from Gemini API."

agents/legal_agent.py

@@ -1,17 +1,17 @@
 # D:\jan-contract\agents\legal_agent.py
 
 import os
-from langchain.prompts import PromptTemplate
+from langchain_core.prompts import PromptTemplate
 from langgraph.graph import StateGraph, END
-from typing import List, TypedDict
+from typing import List, TypedDict, Optional
 from pydantic import BaseModel, Field
 from langchain_core.output_parsers import PydanticOutputParser
 
-# --- Tool and NEW Core Model Loader Imports ---
+# --- Tool and Core Model Loader Imports ---
 from tools.legal_tools import legal_search
 from core_utils.core_model_loaders import load_gemini_llm
 
-# --- Pydantic Models (No Changes) ---
+# --- Pydantic Models ---
 class LegalTriviaItem(BaseModel):
     point: str = Field(description="A concise summary of the legal point or right.")
     explanation: str = Field(description="A brief explanation of what the point means for the user.")
@@ -23,42 +23,72 @@ class LegalTriviaOutput(BaseModel):
 # --- Setup Models and Parsers ---
 parser = PydanticOutputParser(pydantic_object=LegalTriviaOutput)
 
-# --- Initialize the LLM by calling the backend-safe loader function ---
+# --- Initialize the LLM ---
 llm = load_gemini_llm()
 
-# --- LangGraph State (No Changes) ---
+# --- LangGraph State ---
 class LegalAgentState(TypedDict):
     user_request: str
     legal_doc: str
-    legal_trivia: LegalTriviaOutput
+    legal_trivia: Optional[LegalTriviaOutput]
 
-# --- LangGraph Nodes (No Changes) ---
+# --- LangGraph Nodes ---
 def generate_legal_doc(state: LegalAgentState):
-    prompt_text = f"Based on the user's request, generate a simple legal document text for an informal agreement in India. Keep it clear and simple.\n\nUser Request: {state['user_request']}"
-    legal_doc_text = llm.invoke(prompt_text).content
+    """Generates the legal document based on user request."""
+    print("---NODE: Generating Legal Document---")
+    prompt_text = (
+        f"You are a professional legal drafter for the Indian context. "
+        f"Create a simple, clear, and legally valid digital agreement based on the request below. "
+        f"Do not use emojis. Use professional formatting (Markdown). "
+        f"Focus on clarity for informal workers.\n\n"
+        f"User Request: {state['user_request']}"
+    )
+    try:
+        response = llm.invoke(prompt_text)
+        legal_doc_text = response.content if response and response.content else "Error: Failed to generate contract."
+    except Exception as e:
+        print(f"Contract generation error: {e}")
+        legal_doc_text = "Error: Failed to generate contract due to an internal error."
+        
     return {"legal_doc": legal_doc_text}
 
 def get_legal_trivia(state: LegalAgentState):
+    """Fetches relevant legal trivia to educate the user."""
+    print("---NODE: Fetching Legal Trivia---")
     prompt = PromptTemplate(
         template="""
-        You are a specialized legal assistant for India's informal workforce...
+        You are a specialized legal assistant for India's workforce.
+        Based on the user's situation, provide 3 important legal rights or points they should be aware of.
+        
         User's situation: {user_request}
         Web search results: {search_results}
+        
         {format_instructions}
         """,
         input_variables=["user_request", "search_results"],
         partial_variables={"format_instructions": parser.get_format_instructions()},
     )
     chain = prompt | llm | parser
-    search_results = legal_search.invoke(state["user_request"])
-    structured_trivia = chain.invoke({"user_request": state["user_request"], "search_results": search_results})
+    
+    try:
+        search_results = legal_search.invoke(state["user_request"])
+    except Exception as e:
+        print(f"Legal search failed: {e}")
+        search_results = "Search unavailable."
+
+    try:
+        structured_trivia = chain.invoke({"user_request": state["user_request"], "search_results": search_results})
+    except Exception as e:
+        print(f"Trivia generation failed: {e}")
+        structured_trivia = LegalTriviaOutput(trivia=[])
+
     return {"legal_trivia": structured_trivia}
 
-# --- Build Graph (No Changes) ---
+# --- Build Graph ---
 workflow = StateGraph(LegalAgentState)
 workflow.add_node("generate_legal_doc", generate_legal_doc)
 workflow.add_node("get_legal_trivia", get_legal_trivia)
 workflow.set_entry_point("generate_legal_doc")
 workflow.add_edge("generate_legal_doc", "get_legal_trivia")
 workflow.add_edge("get_legal_trivia", END)
-legal_agent = workflow.compile()
+legal_agent = workflow.compile()

agents/scheme_chatbot.py

@@ -1,17 +1,17 @@
 # D:\jan-contract\agents\scheme_chatbot.py
 
 import os
-from langchain.prompts import PromptTemplate
-from langchain.schema.runnable import RunnablePassthrough
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough
 from pydantic import BaseModel, Field
 from langchain_core.output_parsers import PydanticOutputParser
 from typing import List
 
-# --- Tool and NEW Core Model Loader Imports ---
+# --- Tool and Core Model Loader Imports ---
 from tools.scheme_tools import scheme_search
 from core_utils.core_model_loaders import load_gemini_llm
 
-# --- Pydantic Models (No Changes) ---
+# --- Pydantic Models ---
 class GovernmentScheme(BaseModel):
     scheme_name: str = Field(description="The official name of the government scheme.")
     description: str = Field(description="A concise summary of the scheme's objectives and benefits.")
@@ -24,24 +24,33 @@ class SchemeOutput(BaseModel):
 # --- Setup Models and Parsers ---
 parser = PydanticOutputParser(pydantic_object=SchemeOutput)
 
-# --- Initialize the LLM by calling the backend-safe loader function ---
+# --- Initialize the LLM ---
 llm = load_gemini_llm()
 
-# --- Prompt Template (No Changes) ---
+# --- Prompt Template ---
 prompt = PromptTemplate(
     template="""
-    You are an expert assistant for Indian government schemes...
+    You are an expert assistant for Indian government schemes.
+    Find the most relevant official government schemes for the profile below.
+    Focus on accuracy and official sources.
+    
     User Profile: {user_profile}
     Web search results: {search_results}
+    
     {format_instructions}
     """,
     input_variables=["user_profile", "search_results"],
     partial_variables={"format_instructions": parser.get_format_instructions()},
 )
 
-# --- Build Chain (No Changes) ---
+# --- Build Chain ---
 def get_search_results(query: dict):
-    return scheme_search.invoke(query["user_profile"])
+    print(f"---NODE: Searching Schemes for profile: {query['user_profile']}---")
+    try:
+        return scheme_search.invoke(query["user_profile"])
+    except Exception as e:
+        print(f"Scheme search failed: {e}")
+        return "Search unavailable."
 
 scheme_chatbot = (
     {"search_results": get_search_results, "user_profile": RunnablePassthrough()}

components/video_recorder.py

@@ -3,138 +3,211 @@
 import os
 import streamlit as st
 import datetime
-import av
-import numpy as np
-from typing import Optional
-
-from streamlit_webrtc import webrtc_streamer, WebRtcMode
+import streamlit.components.v1 as components
 
 VIDEO_CONSENT_DIR = "video_consents"
 os.makedirs(VIDEO_CONSENT_DIR, exist_ok=True)
 
 def record_consent_video():
     """
-    Improved video recording component with better error handling and reliability.
-    
-    Returns:
-        str | None: The file path of the saved video, or None if not saved yet.
+    Production-grade Video Recorder using RecordRTC.
+    Features:
+    - Camera Selection (Fixes 'wrong camera' issues)
+    - RecordRTC Library (Handles cross-browser compatibility)
+    - Client-side Encoding (Works on Vercel/Heroku)
     """
-    st.info("🎥 **Instructions:** Click START to begin recording, speak your consent, then click STOP to save.")
-    
-    # Initialize session state for video recording
-    if "video_frames_buffer" not in st.session_state:
-        st.session_state.video_frames_buffer = []
-    if "video_recording" not in st.session_state:
-        st.session_state.video_recording = False
-    if "video_processed" not in st.session_state:
-        st.session_state.video_processed = False
-    if "recording_start_time" not in st.session_state:
-        st.session_state.recording_start_time = None
 
-    def video_frame_callback(frame: av.VideoFrame):
-        """Callback to collect video frames during recording"""
-        if st.session_state.video_recording:
-            try:
-                # Convert frame to numpy array for easier handling
-                img = frame.to_ndarray(format="bgr24")
-                st.session_state.video_frames_buffer.append(img)
-            except Exception as e:
-                st.error(f"Error processing video frame: {e}")
+    st.markdown("### 📹 Record Video Consent")
+    st.info("Ensure you grant camera permissions when prompted by your browser.")
+
+    # We use RecordRTC via CDN for maximum robustness
+    html_code = """
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <script src="https://www.WebRTC-Experiment.com/RecordRTC.js"></script>
+        <style>
+            body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; background: transparent; }
+            .container { text-align: center; max-width: 640px; margin: auto; }
+            
+            video { 
+                width: 100%; 
+                border-radius: 8px; 
+                background: #000; 
+                margin-bottom: 10px;
+                box-shadow: 0 2px 10px rgba(0,0,0,0.2);
+            }
+            
+            select {
+                padding: 8px;
+                border-radius: 4px;
+                border: 1px solid #ccc;
+                margin-bottom: 15px;
+                width: 100%;
+                font-size: 14px;
+            }
+            
+            .btn-group { display: flex; gap: 10px; justify-content: center; margin-top: 10px; }
+            
+            button {
+                padding: 10px 20px;
+                border: none;
+                border-radius: 4px;
+                color: white;
+                font-weight: 600;
+                cursor: pointer;
+            }
+            
+            #btn-start { background: #28a745; }
+            #btn-stop { background: #dc3545; }
+            #btn-download { background: #007bff; display: none; }
+            
+            button:disabled { opacity: 0.5; cursor: not-allowed; }
+            #status { margin-top: 10px; font-size: 13px; color: #555; }
+        </style>
+    </head>
+    <body>
+        <div class="container">
+            <select id="video-source"><option value="">Loading cameras...</option></select>
+            <video id="preview" autoplay muted playsinline></video>
+            
+            <div class="btn-group">
+                <button id="btn-start">Start Recording</button>
+                <button id="btn-stop" disabled>Stop</button>
+                <button id="btn-download">Save Video</button>
+            </div>
+            <div id="status">Ready. Select camera and click Start.</div>
+        </div>
+
+        <script>
+            const videoElement = document.getElementById('preview');
+            const videoSelect = document.getElementById('video-source');
+            const btnStart = document.getElementById('btn-start');
+            const btnStop = document.getElementById('btn-stop');
+            const btnDownload = document.getElementById('btn-download');
+            const status = document.getElementById('status');
+            
+            let recorder;
+            let stream;
+
+            // 1. Enumerate Cameras
+            async function getCameras() {
+                try {
+                    await navigator.mediaDevices.getUserMedia({ video: true }); // Request permission first
+                    const devices = await navigator.mediaDevices.enumerateDevices();
+                    const videoDevices = devices.filter(device => device.kind === 'videoinput');
+                    
+                    videoSelect.innerHTML = '';
+                    videoDevices.forEach(device => {
+                        const option = document.createElement('option');
+                        option.value = device.deviceId;
+                        option.text = device.label || `Camera ${videoSelect.length + 1}`;
+                        videoSelect.appendChild(option);
+                    });
+                    
+                    if(videoDevices.length === 0) {
+                         videoSelect.innerHTML = '<option>No cameras found</option>';
+                         status.innerText = "Error: No camera devices detected.";
+                    }
+                } catch (err) {
+                    status.innerText = "Error: Permission denied or no camera. " + err.message;
+                    videoSelect.innerHTML = '<option>Camera Access Denied</option>';
+                }
+            }
+            getCameras();
 
-    # WebRTC streamer configuration
-    webrtc_ctx = webrtc_streamer(
-        key="video-consent-recorder",
-        mode=WebRtcMode.SENDONLY,
-        rtc_configuration={
-            "iceServers": [
-                {"urls": ["stun:stun.l.google.com:19302"]},
-                {"urls": ["stun:stun1.l.google.com:19302"]}
-            ]
-        },
-        media_stream_constraints={
-            "video": {
-                "width": {"ideal": 640},
-                "height": {"ideal": 480},
-                "frameRate": {"ideal": 30}
-            },
-            "audio": False
-        },
-        video_frame_callback=video_frame_callback,
-        async_processing=True,
-    )
+            // 2. Start Recording
+            btnStart.onclick = async () => {
+                const deviceId = videoSelect.value;
+                const constraints = {
+                    video: { deviceId: deviceId ? { exact: deviceId } : undefined },
+                    audio: true
+                };
 
-    # Handle recording state
-    if webrtc_ctx.state.playing and not st.session_state.video_recording:
-        st.session_state.video_recording = True
-        st.session_state.video_processed = False
-        st.session_state.recording_start_time = datetime.datetime.now()
-        st.session_state.video_frames_buffer = []  # Clear previous buffer
-        st.success("🔴 **Recording started!** Speak your consent now...")
-        
-    elif webrtc_ctx.state.playing and st.session_state.video_recording:
-        # Show recording progress
-        frames_captured = len(st.session_state.video_frames_buffer)
-        if st.session_state.recording_start_time:
-            elapsed = (datetime.datetime.now() - st.session_state.recording_start_time).total_seconds()
-            st.caption(f"📹 Recording... Frames: {frames_captured} | Duration: {elapsed:.1f}s")
+                try {
+                    stream = await navigator.mediaDevices.getUserMedia(constraints);
+                    videoElement.srcObject = stream;
+                    videoElement.muted = true; // Avoid feedback
+                    
+                    recorder = new RecordRTC(stream, {
+                        type: 'video',
+                        mimeType: 'video/webm;codecs=vp8',
+                        disableLogs: false
+                    });
+                    
+                    recorder.startRecording();
+                    
+                    btnStart.disabled = true;
+                    btnStop.disabled = false;
+                    btnDownload.style.display = 'none';
+                    status.innerText = "Recording... Speak clearly.";
+                    
+                } catch (err) {
+                    status.innerText = "Failed to start: " + err.message;
+                    console.error(err);
+                }
+            };
 
-    # Process video when recording stops
-    if not webrtc_ctx.state.playing and st.session_state.video_recording and not st.session_state.video_processed:
-        st.session_state.video_recording = False
-        st.session_state.video_processed = True
-        
-        with st.spinner("💾 Processing and saving your recording..."):
-            try:
-                video_frames = st.session_state.video_frames_buffer.copy()
-                
-                # Enhanced validation
-                if len(video_frames) < 30:  # At least 1 second at 30fps
-                    st.warning(f"⚠️ Recording too short ({len(video_frames)} frames). Please record for at least 2-3 seconds.")
-                    st.session_state.video_frames_buffer = []
-                    return None
-                
-                # Generate unique filename
-                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
-                video_filename = os.path.join(VIDEO_CONSENT_DIR, f"consent_{timestamp}.mp4")
-                
-                # Get video dimensions from first frame
-                height, width = video_frames[0].shape[:2]
-                fps = 30
-                
-                # Use OpenCV for more reliable video writing
-                import cv2
-                fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-                out = cv2.VideoWriter(video_filename, fourcc, fps, (width, height))
-                
-                # Write frames
-                for frame in video_frames:
-                    out.write(frame)
-                
-                out.release()
-                
-                # Verify the video was created successfully
-                if os.path.exists(video_filename) and os.path.getsize(video_filename) > 1000:
-                    # Clear the buffer
-                    st.session_state.video_frames_buffer = []
-                    st.session_state.video_filename = video_filename
+            // 3. Stop Recording
+            btnStop.onclick = () => {
+                recorder.stopRecording(() => {
+                    const blob = recorder.getBlob();
+                    const url = URL.createObjectURL(blob);
                     
-                    # Calculate duration
-                    duration = len(video_frames) / fps
-                    st.success(f"✅ **Video saved successfully!**")
-                    st.caption(f"📊 Duration: {duration:.1f}s | Frames: {len(video_frames)} | Size: {os.path.getsize(video_filename)/1024:.1f}KB")
+                    btnStart.disabled = false;
+                    btnStop.disabled = true;
+                    btnDownload.style.display = 'inline-block';
+                    status.innerText = "Recording finished. Download to save.";
                     
-                    return video_filename
-                else:
-                    st.error("❌ Failed to save video file properly.")
-                    return None
+                    // Stop stream
+                    stream.getTracks().forEach(track => track.stop());
+                    videoElement.srcObject = null;
                     
-            except Exception as e:
-                st.error(f"❌ Error saving video: {str(e)}")
-                st.session_state.video_frames_buffer = []
-                return None
+                    // Setup Download
+                    btnDownload.onclick = () => {
+                        const a = document.createElement('a');
+                        a.style.display = 'none';
+                        a.href = url;
+                        a.download = 'recorded_consent.webm';
+                        document.body.appendChild(a);
+                        a.click();
+                        setTimeout(() => {
+                            document.body.removeChild(a);
+                            window.URL.revokeObjectURL(url);
+                        }, 100);
+                        status.innerText = "File kept. Now upload below.";
+                    };
+                });
+            };
+        </script>
+    </body>
+    </html>
+    """
     
-    # Show recording status
-    if st.session_state.video_recording:
-        st.info("🎥 **Recording in progress...** Click STOP when finished.")
+    # Height 600 to accommodate camera dropdown
+    components.html(html_code, height=600)
+
+    st.write("---")
+    st.markdown("### 📤 Upload Your Recording")
+    st.caption("Once you've saved the video above, upload it here to confirm.")
     
-    return None
+    uploaded_file = st.file_uploader("Drop your recorded video here", type=["webm", "mp4", "mov"])
+    if uploaded_file is not None:
+        try:
+             # Process the uploaded file
+             timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+             ext = os.path.splitext(uploaded_file.name)[1] or ".webm"
+             video_filename = os.path.join(VIDEO_CONSENT_DIR, f"consent_upload_{timestamp}{ext}")
+             
+             with open(video_filename, "wb") as f:
+                 f.write(uploaded_file.getbuffer())
+             
+             st.success("✅ Consent Video Received!")
+             st.video(video_filename)
+             return video_filename
+        except Exception as e:
+            st.error(f"Error saving file: {e}")
+            return None
+            
+    return None

core_utils/core_model_loaders.py

@@ -14,8 +14,8 @@ def load_embedding_model():
 
 def load_groq_llm():
     """Loads the Groq LLM without any Streamlit dependencies."""
-    return ChatGroq(temperature=0, model="llama3-8b-8192", api_key=os.getenv("GROQ_API_KEY"))
+    return ChatGroq(temperature=0, model="meta-llama/llama-4-scout-17b-16e-instruct", api_key=os.getenv("GROQ_API_KEY"))
 
 def load_gemini_llm():
     """Loads the Gemini LLM without any Streamlit dependencies."""
-    return ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0)
+    return ChatGoogleGenerativeAI(model="gemini-2.5-flash", temperature=0, max_retries=5)

debug_models.py

@@ -0,0 +1,19 @@
+
+import os
+import google.generativeai as genai
+from dotenv import load_dotenv
+
+load_dotenv()
+api_key = os.getenv("GOOGLE_API_KEY")
+
+if not api_key:
+    print("Error: GOOGLE_API_KEY not found in environment.")
+else:
+    genai.configure(api_key=api_key)
+    print("Listing available models...")
+    try:
+        for m in genai.list_models():
+            if 'generateContent' in m.supported_generation_methods:
+                print(m.name)
+    except Exception as e:
+        print(f"Error listing models: {e}")

main_fastapi.py

@@ -1,39 +1,51 @@
-# D:\jan-contract\main_fastapi.py
+# Enhanced FastAPI Application for Jan-Contract
+# Comprehensive API for India's informal workforce
 
 import os
 import uuid
 import tempfile
 import json
-from typing import Optional, List
-from fastapi import FastAPI, UploadFile, File, HTTPException, Form, BackgroundTasks
-from fastapi.responses import StreamingResponse, JSONResponse
+import datetime
+from typing import Optional, List, Dict, Any
+from fastapi import FastAPI, UploadFile, File, HTTPException, Form, BackgroundTasks, Depends
+from fastapi.responses import StreamingResponse, JSONResponse, FileResponse
 from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, validator
 import io
 import shutil
+import logging
+from dotenv import load_dotenv
 
-# --- Import all our backend logic and agents ---
+# Load environment variables from .env file
+load_dotenv()
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Import all backend logic and agents
 from agents.legal_agent import legal_agent
 from agents.scheme_chatbot import scheme_chatbot
 from agents.demystifier_agent import process_document_for_demystification
 from agents.general_assistant_agent import ask_gemini
 from utils.pdf_generator import generate_formatted_pdf
 
-# --- 1. Initialize FastAPI App ---
+# Initialize FastAPI App
 app = FastAPI(
-    title="Jan-Contract Unified API",
+    title="Jan-Contract Enhanced API",
     description="""
-    A comprehensive API for India's informal workforce providing:
+    🏗️ **Enhanced API for India's Informal Workforce**
+    
+    This comprehensive API provides four core functionalities:
     
-    🏗️ **Contract Generation**: Create digital agreements from plain text
-    🏦 **Scheme Discovery**: Find relevant government schemes and benefits
-    📜 **Document Analysis**: Demystify legal documents with AI-powered insights
-    🤖 **General Assistant**: AI-powered guidance and support
-    🎥 **Media Processing**: Audio/video consent recording and processing
+    1. **Contract Generator**: Create digital agreements from plain text descriptions
+    2. **Scheme Finder**: Discover relevant government schemes and benefits  
+    3. **PDF Demystifier**: AI-powered analysis and explanation of legal documents
+    4. **General Chatbot**: AI-powered assistance for general queries
     
     Built with FastAPI, LangChain, and modern AI technologies.
     """,
-    version="2.0.0",
+    version="2.1.0",
     contact={
         "name": "Jan-Contract Team",
         "email": "support@jan-contract.com"
@@ -44,7 +56,7 @@ app = FastAPI(
     }
 )
 
-# --- 2. CORS Middleware ---
+# CORS Middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],  # Configure appropriately for production
@@ -53,46 +65,113 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# --- 3. Pydantic Models for Request Bodies ---
+# =============================================================================
+# PYDANTIC MODELS FOR REQUEST/RESPONSE VALIDATION
+# =============================================================================
+
 class ContractRequest(BaseModel):
-    user_request: str = Field(..., description="Plain text description of the agreement needed", min_length=10)
+    user_request: str = Field(
+        ..., 
+        description="Plain text description of the agreement needed", 
+        min_length=10,
+        max_length=2000,
+        example="I need a contract for hiring a domestic helper for 6 months with weekly payment of Rs. 3000"
+    )
     
+    @validator('user_request')
+    def validate_request(cls, v):
+        if len(v.strip()) < 10:
+            raise ValueError('Request must be at least 10 characters long')
+        return v.strip()
+
 class SchemeRequest(BaseModel):
-    user_profile: str = Field(..., description="Description of user's situation, needs, or profile", min_length=10)
+    user_profile: str = Field(
+        ..., 
+        description="Description of user's situation, needs, or profile", 
+        min_length=10,
+        max_length=2000,
+        example="I am a 35-year-old woman from rural Maharashtra, working as a daily wage laborer, looking for financial assistance schemes"
+    )
     
+    @validator('user_profile')
+    def validate_profile(cls, v):
+        if len(v.strip()) < 10:
+            raise ValueError('Profile must be at least 10 characters long')
+        return v.strip()
+
 class ChatRequest(BaseModel):
-    session_id: str = Field(..., description="Unique session identifier for document chat")
-    question: str = Field(..., description="Question about the uploaded document", min_length=1)
-    
+    session_id: str = Field(
+        ..., 
+        description="Unique session identifier for document chat",
+        example="123e4567-e89b-12d3-a456-426614174000"
+    )
+    question: str = Field(
+        ..., 
+        description="Question about the uploaded document", 
+        min_length=1,
+        max_length=1000,
+        example="What are the key terms I should be aware of in this contract?"
+    )
+
 class GeneralChatRequest(BaseModel):
-    question: str = Field(..., description="General question for AI assistant", min_length=1)
-    
+    question: str = Field(
+        ..., 
+        description="General question for AI assistant", 
+        min_length=1,
+        max_length=1000,
+        example="What are my rights as a domestic worker in India?"
+    )
+
 class VideoConsentRequest(BaseModel):
     contract_id: str = Field(..., description="Identifier for the contract this consent applies to")
     consent_text: str = Field(..., description="Text of the consent being recorded", min_length=1)
 
-# --- 4. Response Models ---
+# Response Models
 class ApiResponse(BaseModel):
     success: bool
     message: str
-    data: Optional[dict] = None
+    data: Optional[Dict[str, Any]] = None
     error: Optional[str] = None
+    timestamp: str = Field(default_factory=lambda: datetime.datetime.now().isoformat())
 
 class HealthCheck(BaseModel):
     status: str
     version: str
     timestamp: str
-    services: dict
+    services: Dict[str, Any]
+
+# =============================================================================
+# STATE MANAGEMENT
+# =============================================================================
 
-# --- 5. State Management ---
 SESSION_CACHE = {}
 CONTRACT_CACHE = {}
 
-# --- 6. Health Check Endpoint ---
+# =============================================================================
+# UTILITY FUNCTIONS
+# =============================================================================
+
+def get_session_data(session_id: str):
+    """Get session data or raise 404 if not found"""
+    session_data = SESSION_CACHE.get(session_id)
+    if not session_data:
+        raise HTTPException(status_code=404, detail="Session not found. Please upload the document again.")
+    return session_data
+
+def get_contract_data(contract_id: str):
+    """Get contract data or raise 404 if not found"""
+    contract_data = CONTRACT_CACHE.get(contract_id)
+    if not contract_data:
+        raise HTTPException(status_code=404, detail="Contract not found")
+    return contract_data
+
+# =============================================================================
+# HEALTH CHECK ENDPOINT
+# =============================================================================
+
 @app.get("/health", tags=["System"], response_model=HealthCheck)
 async def health_check():
     """Check the health status of the API and its dependencies"""
-    import datetime
     
     # Check if required directories exist
     directories = {
@@ -120,30 +199,57 @@ async def health_check():
     except:
         modules["speech_recognition"] = "❌"
     
+    # Check API keys
+    api_keys = {
+        "GOOGLE_API_KEY": "✅" if os.getenv("GOOGLE_API_KEY") else "❌",
+        "GROQ_API_KEY": "✅" if os.getenv("GROQ_API_KEY") else "❌",
+        "TAVILY_API_KEY": "✅" if os.getenv("TAVILY_API_KEY") else "❌"
+    }
+    
     return HealthCheck(
         status="healthy",
-        version="2.0.0",
+        version="2.1.0",
         timestamp=datetime.datetime.now().isoformat(),
         services={
             "directories": directories,
-            "modules": modules
+            "modules": modules,
+            "api_keys": api_keys
         }
     )
 
-# --- 7. Contract Generation Endpoints ---
+# =============================================================================
+# 1. CONTRACT GENERATOR ENDPOINTS
+# =============================================================================
 
-@app.post("/contract/generate", tags=["Contract Generator"], response_model=ApiResponse)
+@app.post("/api/v1/contracts/generate", tags=["Contract Generator"], response_model=ApiResponse)
 async def generate_contract(request: ContractRequest):
     """
     Generate a digital contract from plain text description.
-    Returns structured JSON with contract text and legal trivia.
+    
+    **Features:**
+    - Creates structured legal documents
+    - Includes relevant legal trivia and rights
+    - Returns contract ID for future reference
+    - Caches contract for retrieval
+    
+    **Use Cases:**
+    - Domestic worker agreements
+    - Service contracts
+    - Rental agreements
+    - Employment contracts
     """
     try:
+        logger.info(f"Generating contract for request: {request.user_request[:100]}...")
+        
         result = legal_agent.invoke({"user_request": request.user_request})
         
         # Cache the contract for later use
         contract_id = str(uuid.uuid4())
-        CONTRACT_CACHE[contract_id] = result
+        CONTRACT_CACHE[contract_id] = {
+            **result,
+            "created_at": datetime.datetime.now().isoformat(),
+            "user_request": request.user_request
+        }
         
         return ApiResponse(
             success=True,
@@ -152,68 +258,151 @@ async def generate_contract(request: ContractRequest):
                 "contract_id": contract_id,
                 "contract": result.get('legal_doc', ''),
                 "legal_trivia": result.get('legal_trivia', {}),
-                "timestamp": str(uuid.uuid4())
+                "created_at": datetime.datetime.now().isoformat()
             }
         )
     except Exception as e:
+        logger.error(f"Contract generation failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Contract generation failed: {str(e)}")
 
-@app.post("/contract/generate-pdf", tags=["Contract Generator"])
+@app.post("/api/v1/contracts/generate-pdf", tags=["Contract Generator"])
 async def generate_contract_pdf(request: ContractRequest):
     """
     Generate a contract and return it as a downloadable PDF file.
+    
+    **Features:**
+    - Creates formatted PDF document
+    - Includes all contract terms and legal trivia
+    - Returns downloadable file
+    - Auto-generates filename with timestamp
     """
     try:
+        logger.info(f"Generating PDF contract for request: {request.user_request[:100]}...")
+        
         result = legal_agent.invoke({"user_request": request.user_request})
         contract_text = result.get('legal_doc', "Error: Could not generate document text.")
         
         pdf_bytes = generate_formatted_pdf(contract_text)
         
+        filename = f"contract_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+        
         return StreamingResponse(
             io.BytesIO(pdf_bytes),
             media_type="application/pdf",
-            headers={"Content-Disposition": f"attachment;filename=digital_agreement_{uuid.uuid4()}.pdf"}
+            headers={"Content-Disposition": f"attachment;filename={filename}"}
         )
     except Exception as e:
+        logger.error(f"PDF generation failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"PDF generation failed: {str(e)}")
 
-@app.get("/contract/{contract_id}", tags=["Contract Generator"], response_model=ApiResponse)
+@app.get("/api/v1/contracts/{contract_id}", tags=["Contract Generator"], response_model=ApiResponse)
 async def get_contract(contract_id: str):
     """Retrieve a previously generated contract by ID"""
-    if contract_id not in CONTRACT_CACHE:
-        raise HTTPException(status_code=404, detail="Contract not found")
+    contract_data = get_contract_data(contract_id)
     
     return ApiResponse(
         success=True,
         message="Contract retrieved successfully",
-        data=CONTRACT_CACHE[contract_id]
+        data=contract_data
+    )
+
+@app.get("/api/v1/contracts", tags=["Contract Generator"], response_model=ApiResponse)
+async def list_contracts():
+    """List all generated contracts with summaries"""
+    contracts = []
+    for contract_id, contract_data in CONTRACT_CACHE.items():
+        contracts.append({
+            "id": contract_id,
+            "summary": contract_data.get('legal_doc', '')[:100] + "...",
+            "created_at": contract_data.get('created_at', 'Unknown'),
+            "user_request": contract_data.get('user_request', '')[:100] + "..."
+        })
+    
+    return ApiResponse(
+        success=True,
+        message=f"Found {len(contracts)} contract(s)",
+        data={"contracts": contracts}
+    )
+
+@app.delete("/api/v1/contracts/{contract_id}", tags=["Contract Generator"], response_model=ApiResponse)
+async def delete_contract(contract_id: str):
+    """Delete a specific contract and its associated data"""
+    contract_data = get_contract_data(contract_id)
+    
+    # Remove contract
+    del CONTRACT_CACHE[contract_id]
+    
+    # Remove associated videos
+    video_dir = "video_consents"
+    if os.path.exists(video_dir):
+        for filename in os.listdir(video_dir):
+            if filename.startswith(f"consent_{contract_id}_"):
+                os.remove(os.path.join(video_dir, filename))
+    
+    return ApiResponse(
+        success=True,
+        message="Contract and associated data deleted successfully"
     )
 
-# --- 8. Scheme Finder Endpoints ---
+# =============================================================================
+# 2. SCHEME FINDER ENDPOINTS
+# =============================================================================
 
-@app.post("/schemes/find", tags=["Scheme Finder"], response_model=ApiResponse)
+@app.post("/api/v1/schemes/find", tags=["Scheme Finder"], response_model=ApiResponse)
 async def find_schemes(request: SchemeRequest):
     """
     Find relevant government schemes based on user profile.
-    Returns list of schemes with descriptions and official links.
+    
+    **Features:**
+    - Searches official government portals
+    - Returns structured scheme information
+    - Includes official links and descriptions
+    - Targets specific user demographics
+    
+    **Use Cases:**
+    - Financial assistance programs
+    - Healthcare schemes
+    - Education benefits
+    - Employment support
+    - Women's empowerment programs
     """
     try:
+        logger.info(f"Finding schemes for profile: {request.user_profile[:100]}...")
+        
         response = scheme_chatbot.invoke({"user_profile": request.user_profile})
+        
         return ApiResponse(
             success=True,
             message="Schemes found successfully",
             data=response
         )
     except Exception as e:
+        logger.error(f"Scheme search failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Scheme search failed: {str(e)}")
 
-# --- 9. Document Demystifier Endpoints ---
+# =============================================================================
+# 3. PDF DEMYSTIFIER ENDPOINTS
+# =============================================================================
 
-@app.post("/demystify/upload", tags=["Document Demystifier"], response_model=ApiResponse)
+@app.post("/api/v1/demystify/upload", tags=["PDF Demystifier"], response_model=ApiResponse)
 async def demystify_upload(file: UploadFile = File(...)):
     """
     Upload a PDF document for AI-powered analysis.
-    Returns analysis report and session ID for follow-up questions.
+    
+    **Features:**
+    - Analyzes legal documents with AI
+    - Generates comprehensive reports
+    - Creates interactive Q&A session
+    - Explains complex legal terms
+    
+    **Supported Formats:**
+    - PDF files only
+    - Maximum size: 50MB
+    
+    **Analysis Includes:**
+    - Document summary
+    - Key legal terms explanation
+    - Overall advice and recommendations
     """
     if file.content_type != "application/pdf":
         raise HTTPException(status_code=400, detail="Invalid file type. Please upload a PDF.")
@@ -222,6 +411,8 @@ async def demystify_upload(file: UploadFile = File(...)):
         raise HTTPException(status_code=400, detail="File too large. Maximum size is 50MB.")
 
     try:
+        logger.info(f"Processing document: {file.filename}")
+        
         # Save to project directory
         upload_dir = "pdfs_demystify"
         os.makedirs(upload_dir, exist_ok=True)
@@ -238,7 +429,8 @@ async def demystify_upload(file: UploadFile = File(...)):
         SESSION_CACHE[session_id] = {
             "rag_chain": analysis_result["rag_chain"],
             "file_path": file_path,
-            "upload_time": str(uuid.uuid4())
+            "upload_time": datetime.datetime.now().isoformat(),
+            "filename": file.filename
         }
 
         return ApiResponse(
@@ -247,55 +439,128 @@ async def demystify_upload(file: UploadFile = File(...)):
             data={
                 "session_id": session_id,
                 "report": analysis_result["report"],
-                "filename": file.filename
+                "filename": file.filename,
+                "upload_time": datetime.datetime.now().isoformat()
             }
         )
     except Exception as e:
+        logger.error(f"Document processing failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Document processing failed: {str(e)}")
 
-@app.post("/demystify/chat", tags=["Document Demystifier"], response_model=ApiResponse)
+@app.post("/api/v1/demystify/chat", tags=["PDF Demystifier"], response_model=ApiResponse)
 async def demystify_chat(request: ChatRequest):
     """
     Ask follow-up questions about an uploaded document.
-    Requires valid session ID from upload endpoint.
+    
+    **Features:**
+    - Interactive Q&A about uploaded documents
+    - Context-aware responses
+    - Legal term explanations
+    - Document-specific insights
+    
+    **Requirements:**
+    - Valid session ID from upload endpoint
+    - Questions must be related to the uploaded document
     """
-    session_data = SESSION_CACHE.get(request.session_id)
-    if not session_data:
-        raise HTTPException(status_code=404, detail="Session not found. Please upload the document again.")
+    session_data = get_session_data(request.session_id)
     
     try:
+        logger.info(f"Processing question for session {request.session_id}: {request.question[:50]}...")
+        
         rag_chain = session_data["rag_chain"]
         response = rag_chain.invoke(request.question)
         
         return ApiResponse(
             success=True,
             message="Question answered successfully",
-            data={"answer": response}
+            data={
+                "answer": response,
+                "session_id": request.session_id,
+                "question": request.question
+            }
         )
     except Exception as e:
+        logger.error(f"Chat processing failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Chat processing failed: {str(e)}")
 
-# --- 10. General Assistant Endpoints ---
+@app.get("/api/v1/demystify/sessions", tags=["PDF Demystifier"], response_model=ApiResponse)
+async def list_demystify_sessions():
+    """List all active document analysis sessions"""
+    sessions = []
+    for session_id, session_data in SESSION_CACHE.items():
+        sessions.append({
+            "session_id": session_id,
+            "filename": session_data.get("filename", "Unknown"),
+            "upload_time": session_data.get("upload_time", "Unknown")
+        })
+    
+    return ApiResponse(
+        success=True,
+        message=f"Found {len(sessions)} active session(s)",
+        data={"sessions": sessions}
+    )
+
+@app.delete("/api/v1/demystify/sessions/{session_id}", tags=["PDF Demystifier"], response_model=ApiResponse)
+async def delete_demystify_session(session_id: str):
+    """Delete a document analysis session and its associated files"""
+    session_data = get_session_data(session_id)
+    
+    # Remove session
+    del SESSION_CACHE[session_id]
+    
+    # Remove associated file
+    file_path = session_data.get("file_path")
+    if file_path and os.path.exists(file_path):
+        os.remove(file_path)
+    
+    return ApiResponse(
+        success=True,
+        message="Session and associated files deleted successfully"
+    )
 
-@app.post("/assistant/chat", tags=["General Assistant"], response_model=ApiResponse)
+# =============================================================================
+# 4. GENERAL CHATBOT ENDPOINTS
+# =============================================================================
+
+@app.post("/api/v1/assistant/chat", tags=["General Assistant"], response_model=ApiResponse)
 async def general_chat(request: GeneralChatRequest):
     """
     Get AI-powered assistance for general questions.
-    Uses Gemini AI model for responses.
+    
+    **Features:**
+    - Uses Google Gemini AI model
+    - Provides helpful responses to general queries
+    - Supports various topics and questions
+    - Context-aware assistance
+    
+    **Use Cases:**
+    - Legal rights information
+    - General guidance
+    - FAQ responses
+    - Educational content
     """
     try:
+        logger.info(f"Processing general chat question: {request.question[:50]}...")
+        
         response = ask_gemini(request.question)
+        
         return ApiResponse(
             success=True,
             message="Response generated successfully",
-            data={"response": response}
+            data={
+                "response": response,
+                "question": request.question
+            }
         )
     except Exception as e:
+        logger.error(f"AI response generation failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"AI response generation failed: {str(e)}")
 
-# --- 11. Media Processing Endpoints ---
+# =============================================================================
+# MEDIA PROCESSING ENDPOINTS (BONUS)
+# =============================================================================
 
-@app.post("/media/upload-video", tags=["Media Processing"], response_model=ApiResponse)
+@app.post("/api/v1/media/upload-video", tags=["Media Processing"], response_model=ApiResponse)
 async def upload_video_consent(
     file: UploadFile = File(...),
     contract_id: str = Form(...),
@@ -303,7 +568,16 @@ async def upload_video_consent(
 ):
     """
     Upload a video consent file for a specific contract.
-    Supports MP4, AVI, MOV formats.
+    
+    **Features:**
+    - Supports multiple video formats
+    - Links to specific contracts
+    - Stores consent text metadata
+    - File size validation
+    
+    **Supported Formats:**
+    - MP4, AVI, MOV
+    - Maximum size: 100MB
     """
     allowed_types = ["video/mp4", "video/avi", "video/quicktime", "video/x-msvideo"]
     
@@ -317,6 +591,8 @@ async def upload_video_consent(
         raise HTTPException(status_code=400, detail="Video too large. Maximum size is 100MB.")
 
     try:
+        logger.info(f"Uploading video consent for contract {contract_id}")
+        
         # Save video to project directory
         upload_dir = "video_consents"
         os.makedirs(upload_dir, exist_ok=True)
@@ -334,13 +610,15 @@ async def upload_video_consent(
                 "video_path": video_path,
                 "contract_id": contract_id,
                 "filename": video_filename,
-                "size": file.size
+                "size": file.size,
+                "consent_text": consent_text
             }
         )
     except Exception as e:
+        logger.error(f"Video upload failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Video upload failed: {str(e)}")
 
-@app.get("/media/videos/{contract_id}", tags=["Media Processing"], response_model=ApiResponse)
+@app.get("/api/v1/media/videos/{contract_id}", tags=["Media Processing"], response_model=ApiResponse)
 async def get_contract_videos(contract_id: str):
     """Get all video consents for a specific contract"""
     try:
@@ -360,7 +638,7 @@ async def get_contract_videos(contract_id: str):
                     "filename": filename,
                     "path": file_path,
                     "size": os.path.getsize(file_path),
-                    "created": str(uuid.uuid4())
+                    "created": datetime.datetime.now().isoformat()
                 })
         
         return ApiResponse(
@@ -369,67 +647,42 @@ async def get_contract_videos(contract_id: str):
             data={"videos": videos}
         )
     except Exception as e:
+        logger.error(f"Video retrieval failed: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Video retrieval failed: {str(e)}")
 
-# --- 12. Utility Endpoints ---
-
-@app.get("/contracts", tags=["Utilities"], response_model=ApiResponse)
-async def list_contracts():
-    """List all generated contracts"""
-    contracts = []
-    for contract_id, contract_data in CONTRACT_CACHE.items():
-        contracts.append({
-            "id": contract_id,
-            "summary": contract_data.get('legal_doc', '')[:100] + "...",
-            "timestamp": str(uuid.uuid4())
-        })
-    
-    return ApiResponse(
-        success=True,
-        message=f"Found {len(contracts)} contract(s)",
-        data={"contracts": contracts}
-    )
-
-@app.delete("/contracts/{contract_id}", tags=["Utilities"], response_model=ApiResponse)
-async def delete_contract(contract_id: str):
-    """Delete a specific contract and its associated data"""
-    if contract_id not in CONTRACT_CACHE:
-        raise HTTPException(status_code=404, detail="Contract not found")
-    
-    # Remove contract
-    del CONTRACT_CACHE[contract_id]
-    
-    # Remove associated videos
-    video_dir = "video_consents"
-    if os.path.exists(video_dir):
-        for filename in os.listdir(video_dir):
-            if filename.startswith(f"consent_{contract_id}_"):
-                os.remove(os.path.join(video_dir, filename))
-    
-    return ApiResponse(
-        success=True,
-        message="Contract and associated data deleted successfully"
-    )
+# =============================================================================
+# ROOT ENDPOINT
+# =============================================================================
 
 @app.get("/", tags=["System"])
 async def root():
-    """API root endpoint with basic information"""
+    """API root endpoint with comprehensive information"""
     return {
-        "message": "Jan-Contract Unified API",
-        "version": "2.0.0",
+        "message": "Jan-Contract Enhanced API",
+        "version": "2.1.0",
         "description": "Comprehensive API for India's informal workforce",
+        "features": [
+            "Contract Generation",
+            "Scheme Discovery", 
+            "Document Analysis",
+            "AI Assistant",
+            "Media Processing"
+        ],
         "endpoints": {
             "health": "/health",
-            "contracts": "/contract/generate",
-            "schemes": "/schemes/find",
-            "demystify": "/demystify/upload",
-            "assistant": "/assistant/chat",
-            "media": "/media/upload-video"
+            "contracts": "/api/v1/contracts/generate",
+            "schemes": "/api/v1/schemes/find",
+            "demystify": "/api/v1/demystify/upload",
+            "assistant": "/api/v1/assistant/chat",
+            "media": "/api/v1/media/upload-video"
         },
-        "docs": "/docs"
+        "docs": "/docs",
+        "redoc": "/redoc"
     }
 
-# --- 13. Error Handlers ---
+# =============================================================================
+# ERROR HANDLERS
+# =============================================================================
 
 @app.exception_handler(HTTPException)
 async def http_exception_handler(request, exc):
@@ -444,6 +697,7 @@ async def http_exception_handler(request, exc):
 
 @app.exception_handler(Exception)
 async def general_exception_handler(request, exc):
+    logger.error(f"Unhandled exception: {str(exc)}")
     return JSONResponse(
         status_code=500,
         content=ApiResponse(
@@ -455,4 +709,4 @@ async def general_exception_handler(request, exc):
 
 if __name__ == "__main__":
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=8000)
+    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)

main_streamlit.py

@@ -4,179 +4,188 @@ import os
 import streamlit as st
 from dotenv import load_dotenv
 
-# --- Agent and Component Imports (Cleaned up) ---
+# --- Agent and Component Imports ---
 from agents.demystifier_agent import process_document_for_demystification
 from components.video_recorder import record_consent_video
 from utils.pdf_generator import generate_formatted_pdf
 from components.chat_interface import chat_interface
-from agents.general_assistant_agent import ask_gemini
+
+
 # --- 1. Initial Setup ---
 load_dotenv()
-st.set_page_config(layout="wide", page_title="Jan-Contract Unified Assistant")
-st.title("Jan-Contract: Your Digital Workforce Assistant")
+st.set_page_config(layout="wide", page_title="Jan-Contract Unified Assistant", page_icon="⚖️")
+
+# Custom CSS for a cleaner look
+st.markdown("""
+<style>
+    .reportview-container {
+        background: #f0f2f6;
+    }
+    .main-header {
+        font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+        color: #333;
+    }
+    h1 {
+        color: #1A73E8;
+    }
+    h2, h3 {
+        color: #424242;
+    }
+    .stButton>button {
+        color: #ffffff;
+        background-color: #1A73E8;
+        border-radius: 5px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+st.title("Jan-Contract: Digital Workforce Assistant")
+st.write("Empowering India's workforce with accessible legal tools and government scheme discovery.")
 
 PDF_UPLOAD_DIR = "pdfs_demystify"
 os.makedirs(PDF_UPLOAD_DIR, exist_ok=True)
 
 # --- 2. Streamlit UI with Tabs ---
-tab1, tab2, tab3, tab4 = st.tabs([
-    "📝 **Contract Generator**", 
-    "🏦 **Scheme Finder**", 
-    "📜 **Document Demystifier & Chat**",
-    "🤖 **General Assistant**"
+tab1, tab2, tab3 = st.tabs([
+    "Contract Generator", 
+    "Scheme Finder", 
+    "Document Demystifier"
 ])
 
 # --- TAB 1: Contract Generator ---
 with tab1:
-    st.header("Create a Simple Digital Agreement")
-    st.write("Turn your everyday language into a clear agreement, then provide video consent.")
+    st.header("Digital Agreement Generator")
+    st.write("Create a clear digital agreement from plain text and record video consent.")
     
-    st.subheader("Step 1: Describe and Generate Your Agreement")
-    user_request = st.text_area("Describe the agreement...", height=120, key="contract_request")
-    
-    # --- FIX: Added a unique key="b1" for consistency ---
-    if st.button("Generate Document & Get Legal Info", type="primary", key="b1"):
-        if user_request:
-            with st.spinner("Generating document..."):
-                from agents.legal_agent import legal_agent
-                result = legal_agent.invoke({"user_request": user_request})
-                st.session_state.legal_result = result
-                # Reset video state for each new contract
-                if 'video_path_from_component' in st.session_state:
-                    del st.session_state['video_path_from_component']
-                if 'frames_buffer' in st.session_state:
-                    del st.session_state['frames_buffer']
-        else:
-            st.error("Please describe the agreement.")
+    col1, col2 = st.columns([1, 1])
     
-    if 'legal_result' in st.session_state:
-        result = st.session_state.legal_result
-        col1, col2 = st.columns(2)
+    with col1:
+        st.subheader("Agreement Details")
+        user_request = st.text_area("Describe the terms of the agreement...", height=150, key="contract_request", placeholder="E.g., I, Rajesh, agree to paint Mr. Sharma's house for 5000 rupees by next Tuesday.")
         
-        with col1:
-            st.subheader("Generated Digital Agreement")
-            st.markdown(result['legal_doc'])
+        if st.button("Generate Agreement", type="primary", key="btn_generate_contract"):
+            if user_request:
+                with st.spinner("Drafting agreement..."):
+                    try:
+                        from agents.legal_agent import legal_agent
+                        result = legal_agent.invoke({"user_request": user_request})
+                        st.session_state.legal_result = result
+                        # Reset video state for new contract
+                        if 'video_path_from_component' in st.session_state:
+                            del st.session_state['video_path_from_component']
+                    except Exception as e:
+                        st.error(f"An error occurred: {e}")
+            else:
+                st.warning("Please describe the agreement details.")
+    
+    with col2:
+        if 'legal_result' in st.session_state:
+            result = st.session_state.legal_result
+            
+            st.subheader("Drafted Agreement")
+            with st.container(border=True):
+                st.markdown(result['legal_doc'])
+            
             pdf_bytes = generate_formatted_pdf(result['legal_doc'])
-            st.download_button(label="⬇️ Download Formatted PDF", data=pdf_bytes, file_name="agreement.pdf")
-        
-        with col2:
-            st.subheader("Relevant Legal Trivia")
-            # --- FIX: Restored the missing trivia display logic ---
+            st.download_button(label="Download PDF", data=pdf_bytes, file_name="agreement.pdf", mime="application/pdf")
+            
             if result.get('legal_trivia') and result['legal_trivia'].trivia:
-                for item in result['legal_trivia'].trivia:
-                    st.markdown(f"- **{item.point}**")
-                    st.caption(item.explanation)
-                    st.markdown(f"[Source Link]({item.source_url})")
-            else:
-                st.write("Could not retrieve structured legal trivia.")
+                with st.expander("Legal Insights"):
+                    for item in result['legal_trivia'].trivia:
+                        st.markdown(f"**{item.point}**")
+                        st.caption(item.explanation)
+                        st.markdown(f"[Source]({item.source_url})")
 
-        st.divider()
-        
-        st.subheader("Step 2: Record Video Consent for this Agreement")
-        
-        # Browser compatibility check
-        st.info("🌐 **Browser Requirements:** This feature works best in Chrome, Firefox, or Edge. Make sure to allow camera access when prompted.")
-        
-        saved_video_path = record_consent_video()
+    st.divider()
+    
+    st.subheader("Video Consent Recording")
+    st.info("Please record a video stating your name and that you agree to the terms above.")
+    
+    saved_video_path = record_consent_video()
 
-        if saved_video_path:
-            st.session_state.video_path_from_component = saved_video_path
+    if saved_video_path:
+        st.session_state.video_path_from_component = saved_video_path
 
-        if st.session_state.get("video_path_from_component"):
-            st.success("✅ Your consent has been recorded and saved!")
-            st.video(st.session_state.video_path_from_component)
-            st.info("This video is now linked to your generated agreement.")
-        else:
-            st.info("💡 **Tip:** If video recording isn't working, try refreshing the page and allowing camera permissions.")
+    if st.session_state.get("video_path_from_component"):
+        st.success("Consent recorded successfully.")
+        st.video(st.session_state.video_path_from_component)
 
-# --- TAB 2: Scheme Finder (Unchanged) ---
+# --- TAB 2: Scheme Finder ---
 with tab2:
-    st.header("Find Relevant Government Schemes")
-    st.write("Describe yourself or your situation to find government schemes that might apply to you.")
+    st.header("Government Scheme Finder")
+    st.write("Find relevant government schemes based on your profile.")
     
-    user_profile = st.text_input("Enter your profile...", key="scheme_profile")
+    user_profile = st.text_input("Enter your profile description...", key="scheme_profile", placeholder="E.g., A female farmer in Maharashtra owning 2 acres of land.")
     
-    if st.button("Find Schemes", type="primary", key="b2"):
+    if st.button("Search Schemes", type="primary", key="btn_find_schemes"):
         if user_profile:
-            with st.spinner("Initializing models and searching for schemes..."):
-                from agents.scheme_chatbot import scheme_chatbot
-                response = scheme_chatbot.invoke({"user_profile": user_profile})
-                st.session_state.scheme_response = response
+            with st.spinner("Searching for schemes..."):
+                try:
+                    from agents.scheme_chatbot import scheme_chatbot
+                    response = scheme_chatbot.invoke({"user_profile": user_profile})
+                    st.session_state.scheme_response = response
+                except Exception as e:
+                    st.error(f"An error occurred during search: {e}")
         else:
-            st.error("Please enter a profile.")
+            st.warning("Please enter a profile description.")
             
     if 'scheme_response' in st.session_state:
         response = st.session_state.scheme_response
-        st.subheader(f"Potential Schemes for: '{user_profile}'")
+        st.subheader(f"Schemes for: '{user_profile}'")
         if response and response.schemes:
             for scheme in response.schemes:
                 with st.container(border=True):
                     st.markdown(f"#### {scheme.scheme_name}")
-                    st.write(f"**Description:** {scheme.description}")
-                    st.link_button("Go to Official Page ➡️", scheme.official_link)
+                    st.write(scheme.description)
+                    st.write(f"**Target Audience:** {scheme.target_audience}")
+                    st.markdown(f"[Official Website]({scheme.official_link})")
+        else:
+            st.info("No specific schemes found. Try a more detailed description.")
 
 # --- TAB 3: Demystifier & Chat ---
 with tab3:
-    st.header("📜 Simplify & Chat With Your Legal Document")
-    st.markdown("Get a plain-English summary of your document, then ask questions using text or your voice.")
+    st.header("Document Demystifier")
+    st.write("Upload a legal document to get a simplified summary and ask questions.")
 
-    uploaded_file = st.file_uploader("Choose a PDF document", type="pdf", key="demystify_uploader")
+    uploaded_file = st.file_uploader("Upload PDF Document", type="pdf", key="demystify_uploader")
 
-    # This button triggers the one-time analysis and embedding process
     if uploaded_file and st.button("Analyze Document", type="primary"):
-        with st.spinner("Performing deep analysis and preparing for chat..."):
-            # Save the uploaded file to a temporary location for processing
-            temp_file_path = os.path.join(PDF_UPLOAD_DIR, uploaded_file.name)
-            with open(temp_file_path, "wb") as f:
-                f.write(uploaded_file.getbuffer())
-            
-            # Call the master controller function from the agent
-            analysis_result = process_document_for_demystification(temp_file_path)
-            
-            # Store the two key results in the session state
-            st.session_state.demystifier_report = analysis_result["report"]
-            st.session_state.rag_chain = analysis_result["rag_chain"]
+        with st.spinner("Analyzing document..."):
+            try:
+                temp_file_path = os.path.join(PDF_UPLOAD_DIR, uploaded_file.name)
+                with open(temp_file_path, "wb") as f:
+                    f.write(uploaded_file.getbuffer())
+                
+                analysis_result = process_document_for_demystification(temp_file_path)
+                
+                st.session_state.demystifier_report = analysis_result["report"]
+                st.session_state.rag_chain = analysis_result["rag_chain"]
+            except Exception as e:
+                st.error(f"Analysis failed: {e}")
 
-    # This UI section only appears after a document has been successfully analyzed
     if 'demystifier_report' in st.session_state:
         st.divider()
-        st.header("Step 1: Automated Document Analysis")
         report = st.session_state.demystifier_report
-        with st.container(border=True):
-            st.subheader("📄 Document Summary")
+        
+        tab_summary, tab_chat = st.tabs(["Summary & Analysis", "Chat with Document"])
+        
+        with tab_summary:
+            st.subheader("Document Summary")
             st.write(report.summary)
-            st.divider()
             
-            st.subheader("🔑 Key Terms Explained")
+            st.subheader("Key Terms Explained")
             for term in report.key_terms:
-                with st.expander(f"**{term.term}**"):
+                with st.expander(f"{term.term}"):
                     st.write(term.explanation)
-                    st.markdown(f"[Learn More Here]({term.resource_link})")
-            st.divider()
+                    st.markdown(f"[Learn More]({term.resource_link})")
             
-            st.success(f"**Overall Advice:** {report.overall_advice}")
+            st.info(f"**Advice:** {report.overall_advice}")
+        
+        with tab_chat:
+            st.subheader("Ask Questions")
+            chat_interface(
+                handler_function=st.session_state.rag_chain.invoke, 
+                session_state_key="doc_chat_history"
+            )
 
-        st.divider()
 
-        st.header("Step 2: Ask Follow-up Questions")
-        # Call our reusable chat component, passing the RAG chain specific to this document.
-        # The RAG chain's .invoke method is the handler function.
-        chat_interface(
-            handler_function=st.session_state.rag_chain.invoke, 
-            session_state_key="doc_chat_history"  # Use a unique key for this chat's history
-        )
-            
-    elif not uploaded_file:
-        st.info("Upload a PDF document to begin analysis and enable chat.")
-
-# --- TAB 4: General Assistant (Complete) ---
-with tab4:
-    st.header("🤖 General Assistant")
-    st.markdown("Ask a general question and get a response directly from the Gemini AI model. You can use text or your voice.")
-
-    # Call our reusable chat component.
-    # This time, we pass the simple `ask_gemini` function as the handler.
-    chat_interface(
-        handler_function=ask_gemini,
-        session_state_key="general_chat_history" # Use a different key for this chat's history
-    )

requirements.txt

@@ -5,6 +5,7 @@ langchain-core>=0.2.0
 langchain>=0.2.0
 langchain-community>=0.2.0
 langgraph>=0.2.0
+langchain-text-splitters>=0.2.0
 
 # LLM Integrations
 langchain_google_genai>=0.1.0
@@ -26,7 +27,7 @@ streamlit>=1.28.0
 
 # Video and Audio Processing
 streamlit-webrtc>=0.63.4
-opencv-python-headless>=4.8.0
+opencv-python>=4.8.0
 av>=14.0.0
 SpeechRecognition>=3.10.0
 gTTS>=2.4.0

run_app.py

@@ -1,106 +0,0 @@
-#!/usr/bin/env python3
-"""
-Jan-Contract App Launcher
-This script helps you run the Streamlit app with proper configuration.
-"""
-
-import os
-import sys
-import subprocess
-import webbrowser
-import time
-
-
-def check_dependencies():
-    """Check if all required dependencies are installed"""
-    # Map human/package names to actual importable module names
-    required_modules = [
-        ("streamlit", "streamlit"),
-        ("streamlit-webrtc", "streamlit_webrtc"),
-        ("opencv-python-headless", "cv2"),  # import cv2, not opencv_python_headless
-        ("av", "av"),
-        ("SpeechRecognition", "speech_recognition"),
-        ("gTTS", "gtts"),
-        ("numpy", "numpy"),
-    ]
-
-    missing = []
-    for package_label, module_name in required_modules:
-        try:
-            __import__(module_name)
-        except ImportError:
-            missing.append(package_label)
-
-    if missing:
-        print("❌ Missing dependencies:")
-        for package in missing:
-            print(f"   - {package}")
-        print("\n💡 Install missing packages with:")
-        print("   pip install -r requirements.txt")
-        return False
-
-    print("✅ All dependencies are installed!")
-    return True
-
-
-def check_directories():
-    """Check if required directories exist"""
-    required_dirs = ['video_consents', 'pdfs_demystify']
-
-    for dir_name in required_dirs:
-        if not os.path.exists(dir_name):
-            os.makedirs(dir_name, exist_ok=True)
-            print(f"📁 Created directory: {dir_name}")
-
-    print("✅ All directories are ready!")
-
-
-def main():
-    print("🚀 Jan-Contract App Launcher")
-    print("=" * 40)
-
-    # Check dependencies
-    if not check_dependencies():
-        print("\n❌ Please install missing dependencies before running the app.")
-        return
-
-    # Check directories
-    check_directories()
-
-    print("\n🌐 Starting Streamlit app...")
-    print("💡 The app will open in your default browser.")
-    print("💡 If it doesn't open automatically, go to: http://localhost:8501")
-    print("\n📋 Tips for best experience:")
-    print("   - Use Chrome, Firefox, or Edge")
-    print("   - Allow camera and microphone permissions")
-    print("   - Record videos for at least 2-3 seconds")
-    print("   - Speak clearly for voice input")
-
-    # Start the Streamlit app using `python -m streamlit` so PATH is not required
-    try:
-        # Open browser after a short delay
-        def open_browser():
-            time.sleep(3)
-            webbrowser.open('http://localhost:8501')
-
-        import threading
-        browser_thread = threading.Thread(target=open_browser)
-        browser_thread.daemon = True
-        browser_thread.start()
-
-        # Run Streamlit
-        subprocess.run([
-            sys.executable, '-m', 'streamlit', 'run', 'main_streamlit.py',
-            '--server.port', '8501',
-            '--server.address', 'localhost'
-        ])
-
-    except KeyboardInterrupt:
-        print("\n👋 App stopped by user.")
-    except Exception as e:
-        print(f"\n❌ Error starting app: {e}")
-        print("💡 Try running manually: python -m streamlit run main_streamlit.py")
-
-
-if __name__ == "__main__":
-    main()