Upload 10 files

.dockerignore

@@ -0,0 +1,31 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+.venv
+*.egg-info/
+dist/
+build/
+*.log
+.DS_Store
+.env
+.git/
+.gitignore
+README.md
+DEPLOYMENT.md
+HACKATHON_DEMO.md
+IMPLEMENTATION_SUMMARY.md
+QUICKSTART.md
+QUICK_REFERENCE.md
+*.md
+test_*.py
+client_example.py
+docker-compose.yml
+start.sh
+start.ps1
+start_hackathon.sh
+start_hackathon.ps1

Dockerfile

@@ -0,0 +1,45 @@
+# Optimized Dockerfile for Hugging Face Spaces
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+
+# Install dependencies in stages for better caching
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir \
+    fastapi==0.104.0 \
+    uvicorn[standard]==0.24.0 \
+    pydantic==2.0.0 \
+    python-multipart==0.0.6 \
+    python-dotenv==1.0.0 \
+    requests==2.31.0 \
+    googletrans==4.0.0rc1 \
+    langdetect==1.0.9 && \
+    pip install --no-cache-dir \
+    numpy==1.24.0 \
+    pandas==2.0.0 \
+    scikit-learn==1.3.0 && \
+    pip install --no-cache-dir \
+    torch==2.0.0 \
+    transformers==4.35.0 \
+    sentence-transformers==2.2.0
+
+# Copy application code
+COPY . .
+
+# Expose port (Hugging Face Spaces uses 7860 by default)
+EXPOSE 7860
+
+# Set environment variable for port
+ENV PORT=7860
+
+# Start the application
+CMD ["python", "app.py"]

README.md

@@ -1,11 +1,32 @@
----
-title: Verdicto Ml
-emoji: 🔥
-colorFrom: gray
-colorTo: purple
-sdk: docker
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: LexAI ML Backend
+emoji: ⚖️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+license: apache-2.0
+---
+
+# LexAI ML Backend - Hugging Face Space
+
+This Space hosts the complete ML backend for LexAI, providing:
+
+- **Bias Detection**: InLegalBERT-powered analysis of legal documents
+- **Outcome Prediction**: AI-driven case outcome forecasting
+- **Multilingual Translation**: Support for 9 Indian languages
+- **Document Generation**: Automated legal document creation
+- **Text Simplification**: Plain language conversion
+- **What-If Simulation**: Scenario analysis for legal cases
+
+## API Documentation
+
+Once deployed, visit `/docs` for interactive API documentation.
+
+## Environment Variables
+
+No environment variables required - all models are loaded automatically.
+
+## Usage
+

api.py

@@ -0,0 +1,604 @@
+"""
+Unified FastAPI API for InLegalBERT Analysis & Hackathon Features
+==================================================================
+
+This module provides REST API endpoints for:
+1. Bias detection and outcome prediction (InLegalBERT)
+2. Multilingual translation (9 languages)
+3. Legal document generation (4 types)
+4. Plain language simplification
+5. What-if simulation engine
+6. Sensitivity analysis
+
+All features consolidated into a single API on port 8001.
+"""
+
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+import uvicorn
+from datetime import datetime
+
+from bias_prediction_engine import analyze_legal_case, get_model
+from translation_service import get_translation_service
+from document_generator import get_document_generator
+from simulation_engine import get_simulation_engine
+
+# ============================================================================
+# FASTAPI APP SETUP
+# ============================================================================
+
+app = FastAPI(
+    title="LexAI Unified ML API",
+    description="Comprehensive legal AI analysis: bias detection, translation, document generation, and simulation",
+    version="2.0.0"
+)
+
+# CORS configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure appropriately for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ============================================================================
+# PYDANTIC MODELS (Request/Response Schemas)
+# ============================================================================
+
+# --- Bias Analysis Models ---
+class CaseMetadata(BaseModel):
+    """Optional metadata for case analysis"""
+    case_type: Optional[str] = Field(None, description="Type of case (criminal, civil, bail, etc.)")
+    jurisdiction: Optional[str] = Field(None, description="Court jurisdiction")
+    year: Optional[int] = Field(None, description="Case year")
+    
+
+class HistoricalCase(BaseModel):
+    """Historical case data for systemic bias analysis"""
+    outcome: str = Field(..., description="Case outcome (conviction, acquittal, etc.)")
+    gender: Optional[str] = Field(None, description="Gender of defendant")
+    region: Optional[str] = Field(None, description="Geographic region")
+    caste: Optional[str] = Field(None, description="Caste category")
+    case_type: Optional[str] = Field(None, description="Type of case")
+    year: Optional[int] = Field(None, description="Year of case")
+
+
+class AnalysisRequest(BaseModel):
+    """Main request model for comprehensive analysis"""
+    case_text: str = Field(..., description="Legal document/FIR/judgment text", min_length=10)
+    rag_summary: Optional[str] = Field(None, description="AI-generated summary for RAG bias detection")
+    source_documents: Optional[List[str]] = Field(None, description="Source documents used for RAG")
+    historical_cases: Optional[List[HistoricalCase]] = Field(None, description="Historical cases for systemic analysis")
+    case_metadata: Optional[CaseMetadata] = Field(None, description="Case metadata")
+
+
+class DocumentBiasRequest(BaseModel):
+    """Request for document-only bias detection"""
+    case_text: str = Field(..., description="Legal document text")
+    threshold: float = Field(0.15, ge=0.0, le=1.0, description="Bias detection threshold")
+
+
+class RAGBiasRequest(BaseModel):
+    """Request for RAG output bias detection"""
+    rag_summary: str = Field(..., description="AI-generated summary")
+    source_documents: List[str] = Field(..., description="Source documents")
+
+
+class SystemicBiasRequest(BaseModel):
+    """Request for systemic bias analysis"""
+    historical_cases: List[HistoricalCase] = Field(..., description="Historical case data")
+
+
+class OutcomePredictionRequest(BaseModel):
+    """Request for outcome prediction only"""
+    case_text: str = Field(..., description="Legal case text")
+    case_metadata: Optional[CaseMetadata] = Field(None, description="Optional case metadata")
+
+
+class AnalysisResponse(BaseModel):
+    """Response model for analysis results"""
+    status: str
+    analysis_id: str
+    timestamp: str
+    document_bias: Optional[Dict[str, Any]] = None
+    rag_bias: Optional[Dict[str, Any]] = None
+    systemic_bias: Optional[Dict[str, Any]] = None
+    outcome_prediction: Optional[Dict[str, Any]] = None
+
+
+# --- Translation & Simplification Models ---
+class TranslateRequest(BaseModel):
+    text: str = Field(..., description="Text to translate")
+    source_lang: str = Field("auto", description="Source language (auto-detect)")
+    target_lang: str = Field("en", description="Target language")
+
+
+class SimplifyRequest(BaseModel):
+    legal_text: str = Field(..., description="Complex legal text")
+    reading_level: str = Field("simple", description="Reading level (simple/intermediate)")
+
+
+# --- Document Generation Models ---
+class DocumentGenerateRequest(BaseModel):
+    document_type: str = Field(..., description="Type: bail_application, fir_complaint, legal_notice, petition")
+    details: Dict[str, Any] = Field(..., description="Document details")
+
+
+# --- Simulation Models ---
+class SimulationRequest(BaseModel):
+    base_case: Dict[str, Any] = Field(..., description="Original case facts")
+    modifications: Dict[str, Any] = Field(..., description="Modifications to test")
+
+
+class SensitivityRequest(BaseModel):
+    case_facts: str = Field(..., description="Case facts for sensitivity analysis")
+
+
+# ============================================================================
+# ROOT & HEALTH CHECK
+# ============================================================================
+
+@app.get("/")
+async def root():
+    """API health check and feature overview"""
+    return {
+        "service": "LexAI Unified ML API",
+        "status": "operational",
+        "version": "2.0.0",
+        "port": 8001,
+        "features": {
+            "bias_analysis": "InLegalBERT-powered bias detection",
+            "outcome_prediction": "Legal case outcome prediction",
+            "translation": "9 Indian languages supported",
+            "simplification": "Plain language conversion",
+            "document_generation": "4 legal document types",
+            "simulation": "What-if scenario analysis"
+        },
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+# ============================================================================
+# BIAS ANALYSIS ENDPOINTS
+# ============================================================================
+
+@app.post("/api/v1/analyze/comprehensive", response_model=AnalysisResponse)
+async def comprehensive_analysis(request: AnalysisRequest):
+    """
+    Perform comprehensive legal case analysis including:
+    - Document bias detection
+    - RAG output bias detection (if RAG summary provided)
+    - Systemic bias analysis (if historical cases provided)
+    - Outcome prediction
+    """
+    try:
+        # Convert Pydantic models to dicts
+        historical_cases_dict = None
+        if request.historical_cases:
+            historical_cases_dict = [case.dict() for case in request.historical_cases]
+        
+        case_metadata_dict = None
+        if request.case_metadata:
+            case_metadata_dict = request.case_metadata.dict()
+        
+        # Run analysis
+        results = analyze_legal_case(
+            case_text=request.case_text,
+            rag_summary=request.rag_summary,
+            source_documents=request.source_documents,
+            historical_cases=historical_cases_dict,
+            case_metadata=case_metadata_dict
+        )
+        
+        return results
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
+
+
+@app.post("/api/v1/analyze/document-bias")
+async def document_bias_analysis(request: DocumentBiasRequest):
+    """Analyze document for textual biases (gender, caste, region, etc.)"""
+    try:
+        model = get_model()
+        results = model.detect_document_bias(request.case_text, request.threshold)
+        
+        return {
+            "status": "success",
+            "analysis_id": f"doc_bias_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "timestamp": datetime.now().isoformat(),
+            "results": results
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Document bias analysis failed: {str(e)}")
+
+
+@app.post("/api/v1/analyze/rag-bias")
+async def rag_bias_analysis(request: RAGBiasRequest):
+    """Analyze RAG-generated output for tone, interpretive, and selectivity biases"""
+    try:
+        model = get_model()
+        results = model.detect_rag_output_bias(
+            request.rag_summary,
+            request.source_documents
+        )
+        
+        return {
+            "status": "success",
+            "analysis_id": f"rag_bias_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "timestamp": datetime.now().isoformat(),
+            "results": results
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"RAG bias analysis failed: {str(e)}")
+
+
+@app.post("/api/v1/analyze/systemic-bias")
+async def systemic_bias_analysis(request: SystemicBiasRequest):
+    """Analyze historical cases for systemic and statistical biases"""
+    try:
+        model = get_model()
+        historical_cases_dict = [case.dict() for case in request.historical_cases]
+        results = model.detect_systemic_bias(historical_cases_dict)
+        
+        return {
+            "status": "success",
+            "analysis_id": f"systemic_bias_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "timestamp": datetime.now().isoformat(),
+            "results": results
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Systemic bias analysis failed: {str(e)}")
+
+
+@app.post("/api/v1/predict/outcome")
+async def outcome_prediction(request: OutcomePredictionRequest):
+    """Predict legal case outcome with confidence score"""
+    try:
+        model = get_model()
+        case_metadata_dict = None
+        if request.case_metadata:
+            case_metadata_dict = request.case_metadata.dict()
+        
+        results = model.predict_outcome(request.case_text, case_metadata_dict)
+        
+        return {
+            "status": "success",
+            "analysis_id": f"prediction_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+            "timestamp": datetime.now().isoformat(),
+            "results": results
+        }
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Outcome prediction failed: {str(e)}")
+
+
+@app.get("/api/v1/model/info")
+async def model_info():
+    """Get information about the loaded model"""
+    try:
+        model = get_model()
+        return {
+            "model_name": "InLegalBERT (law-ai/InLegalBERT)",
+            "device": str(model.device),
+            "bias_types_supported": list(model.bias_keywords.keys()),
+            "status": "loaded",
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Model info retrieval failed: {str(e)}")
+
+
+# ============================================================================
+# TRANSLATION ENDPOINTS
+# ============================================================================
+
+@app.post("/api/v1/translate/query")
+async def translate_query(request: TranslateRequest):
+    """
+    Translate user query to English for processing
+    
+    **Supports**: Hindi, Tamil, Telugu, Bengali, Marathi, Gujarati, Kannada, Malayalam
+    """
+    try:
+        service = get_translation_service()
+        result = service.translate_query(
+            request.text,
+            request.source_lang,
+            request.target_lang
+        )
+        
+        return {
+            "status": "success",
+            "translation": result,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/v1/translate/response")
+async def translate_response(request: TranslateRequest):
+    """Translate AI response to user's language"""
+    try:
+        service = get_translation_service()
+        result = service.translate_response(
+            request.text,
+            request.target_lang
+        )
+        
+        return {
+            "status": "success",
+            "translation": result,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/v1/languages")
+async def get_supported_languages():
+    """Get list of supported languages"""
+    service = get_translation_service()
+    return {
+        "languages": service.get_supported_languages(),
+        "total": len(service.get_supported_languages())
+    }
+
+
+# ============================================================================
+# SIMPLIFICATION ENDPOINTS
+# ============================================================================
+
+@app.post("/api/v1/simplify")
+async def simplify_legal_text(request: SimplifyRequest):
+    """
+    Convert complex legal language to plain language
+    
+    **Perfect for citizens!**
+    """
+    try:
+        service = get_translation_service()
+        result = service.simplify_legal_text(
+            request.legal_text,
+            request.reading_level
+        )
+        
+        return {
+            "status": "success",
+            "simplification": result,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ============================================================================
+# DOCUMENT GENERATION ENDPOINTS
+# ============================================================================
+
+@app.post("/api/v1/generate/document")
+async def generate_document(request: DocumentGenerateRequest):
+    """
+    Generate legal documents from templates
+    
+    **Available Types:**
+    - `bail_application`: Bail application under CrPC
+    - `fir_complaint`: FIR/Complaint for police
+    - `legal_notice`: Legal notice
+    - `petition`: Court petition
+    """
+    try:
+        generator = get_document_generator()
+        
+        if request.document_type == 'bail_application':
+            result = generator.generate_bail_application(request.details)
+        elif request.document_type == 'fir_complaint':
+            result = generator.generate_fir(request.details)
+        elif request.document_type == 'legal_notice':
+            result = generator.generate_legal_notice(request.details)
+        elif request.document_type == 'petition':
+            result = generator.generate_petition(request.details)
+        else:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Unknown document type: {request.document_type}"
+            )
+        
+        return {
+            "status": "success",
+            "document": result,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/v1/templates")
+async def get_templates():
+    """Get list of available document templates"""
+    generator = get_document_generator()
+    return {
+        "templates": generator.get_template_list(),
+        "total": len(generator.get_template_list())
+    }
+
+
+# ============================================================================
+# SIMULATION ENDPOINTS
+# ============================================================================
+
+@app.post("/api/v1/simulate/outcome")
+async def simulate_outcome(request: SimulationRequest):
+    """
+    What-If Simulation: See how case facts affect outcomes
+    
+    **Modifications Available:**
+    - `remove_prior_conviction`: Remove criminal history
+    - `add_strong_alibi`: Add alibi evidence
+    - `improve_witness_credibility`: Enhance witness reliability
+    - `add_mitigating_factors`: Add favorable circumstances
+    - `reduce_flight_risk`: Show community ties
+    - `enhance_evidence`: Strengthen evidence quality
+    """
+    try:
+        engine = get_simulation_engine()
+        result = engine.simulate_outcome(
+            request.base_case,
+            request.modifications
+        )
+        
+        return {
+            "status": "success",
+            "simulation": result,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/v1/simulate/sensitivity")
+async def sensitivity_analysis(request: SensitivityRequest):
+    """
+    Sensitivity Analysis: Test impact of each factor independently
+    
+    Shows which factors have the most influence on case outcome
+    """
+    try:
+        engine = get_simulation_engine()
+        result = engine.sensitivity_analysis(request.case_facts)
+        
+        return {
+            "status": "success",
+            "sensitivity": result,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+# ============================================================================
+# DEMO ENDPOINT
+# ============================================================================
+
+@app.get("/api/v1/demo/complete")
+async def complete_demo():
+    """
+    Complete feature demonstration
+    
+    Shows all capabilities in one response
+    """
+    
+    # 1. Translation
+    translation_service = get_translation_service()
+    translation_demo = translation_service.translate_query(
+        "मुझे जमानत चाहिए",
+        "hi",
+        "en"
+    )
+    
+    # 2. Simplification
+    simplification_demo = translation_service.simplify_legal_text(
+        "The appellant filed a habeas corpus petition under Article 226.",
+        "simple"
+    )
+    
+    # 3. Document Generation
+    doc_generator = get_document_generator()
+    doc_demo = doc_generator.generate_bail_application({
+        'applicant_name': 'Demo User',
+        'state': 'Demo State',
+        'first_time_offender': True
+    })
+    
+    # 4. Simulation
+    sim_engine = get_simulation_engine()
+    sim_demo = sim_engine.simulate_outcome(
+        {'facts': 'Accused has prior conviction. Witnesses unreliable.'},
+        {'remove_prior_conviction': True, 'improve_witness_credibility': True}
+    )
+    
+    return {
+        "status": "success",
+        "demo_features": {
+            "1_translation": {
+                "feature": "Multilingual Support",
+                "input": "मुझे जमानत चाहिए (Hindi)",
+                "output": translation_demo['translated_text'],
+                "languages_supported": 9
+            },
+            "2_simplification": {
+                "feature": "Plain Language Conversion",
+                "original": "habeas corpus petition under Article 226",
+                "simplified": simplification_demo['simplified_text'][:100] + "...",
+                "reading_level": "Grade 8"
+            },
+            "3_document_generation": {
+                "feature": "Legal Document Generator",
+                "document_type": "Bail Application",
+                "length": len(doc_demo['content']),
+                "editable": doc_demo['editable'],
+                "preview": doc_demo['content'][:300] + "..."
+            },
+            "4_simulation": {
+                "feature": "What-If Simulation",
+                "base_outcome": sim_demo['base_case']['prediction']['predictedOutcome'],
+                "modified_outcome": sim_demo['modified_case']['prediction']['predictedOutcome'],
+                "outcome_changed": sim_demo['impact_analysis']['outcome_changed'],
+                "confidence_change": f"{sim_demo['impact_analysis']['confidence_change_percent']}%"
+            }
+        },
+        "total_features_demonstrated": 4,
+        "ai_models_used": [
+            "InLegalBERT (Bias Detection)",
+            "Google Translate (Multilingual)",
+            "Template-based Document Generation",
+            "Simulation Engine"
+        ],
+        "timestamp": datetime.now().isoformat()
+    }
+
+
+# ============================================================================
+# STARTUP EVENT
+# ============================================================================
+
+@app.on_event("startup")
+async def startup_event():
+    """Initialize all services on startup"""
+    print("=" * 70)
+    print("🚀 LEXAI UNIFIED ML API")
+    print("=" * 70)
+    print("✅ InLegalBERT Model: Loading...")
+    get_model()
+    print("✅ InLegalBERT Model: Ready")
+    print("✅ Translation Service: Ready (9 languages)")
+    print("✅ Document Generator: Ready (4 templates)")
+    print("✅ Simplification: Ready")
+    print("✅ Simulation Engine: Ready")
+    print("=" * 70)
+    print("📍 API Docs: http://localhost:8001/docs")
+    print("🎯 Demo Endpoint: http://localhost:8001/api/v1/demo/complete")
+    print("=" * 70)
+
+
+# ============================================================================
+# MAIN ENTRY POINT
+# ============================================================================
+
+if __name__ == "__main__":
+    import os
+    port = int(os.environ.get("PORT", 8001))
+    uvicorn.run(
+        "api:app",
+        host="0.0.0.0",
+        port=port,
+        reload=False,
+        log_level="info"
+    )

app.py

@@ -0,0 +1,14 @@
+# Hugging Face Spaces entry point
+import os
+from api import app
+
+# This file is used by Hugging Face Spaces to start the application
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))  # HF Spaces default port
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=port,
+        log_level="info"
+    )

bias_prediction_engine.py

@@ -0,0 +1,610 @@
+"""
+Bias Detection and Outcome Prediction Engine using InLegalBERT
+================================================================
+
+This module provides:
+1. Document/Text bias detection (gender, region, caste, etc.)
+2. RAG output bias detection (tone, interpretive bias)
+3. Systemic/Statistical bias analysis
+4. Legal outcome prediction with confidence scores
+
+Model: InLegalBERT (Hugging Face pretrained for Indian legal cases)
+"""
+
+import torch
+import numpy as np
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModel
+from typing import Dict, List, Any, Optional, Union
+import re
+from collections import Counter
+import json
+from datetime import datetime
+import warnings
+warnings.filterwarnings('ignore')
+
+# ============================================================================
+# MODEL INITIALIZATION
+# ============================================================================
+
+class InLegalBERTEngine:
+    """
+    Main engine for bias detection and outcome prediction using InLegalBERT
+    """
+    
+    def __init__(self, model_name: str = "law-ai/InLegalBERT"):
+        """
+        Initialize the InLegalBERT model and tokenizer
+        
+        Args:
+            model_name: HuggingFace model identifier
+        """
+        print(f"Loading InLegalBERT model: {model_name}")
+        
+        # Load tokenizer and base model for embeddings
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.base_model = AutoModel.from_pretrained(model_name)
+        
+        # Set device
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.base_model.to(self.device)
+        self.base_model.eval()
+        
+        # Bias detection keywords (Indian legal context)
+        self.bias_keywords = {
+            'gender': [
+                'woman', 'women', 'girl', 'female', 'lady', 'wife', 'mother',
+                'man', 'men', 'boy', 'male', 'husband', 'father', 'manhood', 'womanhood'
+            ],
+            'caste': [
+                'scheduled caste', 'sc', 'st', 'scheduled tribe', 'obc', 'backward class',
+                'dalit', 'brahmin', 'upper caste', 'lower caste', 'caste', 'jati'
+            ],
+            'religion': [
+                'hindu', 'muslim', 'christian', 'sikh', 'buddhist', 'jain',
+                'religious', 'communal', 'minority', 'majority community'
+            ],
+            'region': [
+                'north', 'south', 'east', 'west', 'rural', 'urban', 'tribal',
+                'metropolitan', 'village', 'city', 'state', 'region'
+            ],
+            'socioeconomic': [
+                'poor', 'rich', 'wealthy', 'poverty', 'income', 'economically',
+                'below poverty line', 'bpl', 'weaker section', 'privileged'
+            ],
+            'age': [
+                'minor', 'juvenile', 'child', 'elderly', 'senior citizen', 'youth',
+                'old', 'young', 'aged'
+            ]
+        }
+        
+        print(f"Model loaded successfully on {self.device}")
+    
+    # ========================================================================
+    # UTILITY FUNCTIONS
+    # ========================================================================
+    
+    def get_embeddings(self, text: str) -> torch.Tensor:
+        """
+        Get BERT embeddings for input text
+        
+        Args:
+            text: Input text string
+            
+        Returns:
+            torch.Tensor: Embedding vector
+        """
+        # Tokenize
+        inputs = self.tokenizer(
+            text,
+            return_tensors="pt",
+            truncation=True,
+            max_length=512,
+            padding=True
+        ).to(self.device)
+        
+        # Get embeddings
+        with torch.no_grad():
+            outputs = self.base_model(**inputs)
+            # Use CLS token embedding (first token)
+            embeddings = outputs.last_hidden_state[:, 0, :]
+        
+        return embeddings
+    
+    def compute_bias_score(self, text: str, bias_type: str) -> float:
+        """
+        Compute bias score for a specific bias type using keyword frequency
+        and contextual analysis
+        
+        Args:
+            text: Input text
+            bias_type: Type of bias (gender, caste, etc.)
+            
+        Returns:
+            float: Bias score between 0 and 1
+        """
+        text_lower = text.lower()
+        keywords = self.bias_keywords.get(bias_type, [])
+        
+        # Count keyword occurrences
+        keyword_count = sum(text_lower.count(keyword) for keyword in keywords)
+        
+        # Normalize by text length (words)
+        word_count = len(text.split())
+        if word_count == 0:
+            return 0.0
+        
+        # Calculate frequency-based score
+        frequency_score = min(keyword_count / word_count * 10, 1.0)
+        
+        # Get contextual score using embeddings (simplified)
+        # In production, use a fine-tuned classifier
+        contextual_score = frequency_score * 0.8  # Simplified
+        
+        return round(contextual_score, 3)
+    
+    # ========================================================================
+    # 1. DOCUMENT/TEXT BIAS DETECTION
+    # ========================================================================
+    
+    def detect_document_bias(self, text: str, threshold: float = 0.15) -> Dict[str, Any]:
+        """
+        Detect various biases in legal documents/FIRs/judgments
+        
+        Args:
+            text: Legal document text
+            threshold: Minimum score to flag a bias (default 0.15)
+            
+        Returns:
+            Dict containing bias flags and detailed scores
+        """
+        bias_scores = {}
+        bias_flags = []
+        
+        # Analyze each bias type
+        for bias_type in self.bias_keywords.keys():
+            score = self.compute_bias_score(text, bias_type)
+            bias_scores[bias_type] = score
+            
+            if score >= threshold:
+                bias_flags.append(bias_type)
+        
+        # Determine severity levels
+        bias_details = []
+        for bias_type, score in bias_scores.items():
+            if score >= threshold:
+                severity = "high" if score >= 0.4 else "medium" if score >= 0.25 else "low"
+                bias_details.append({
+                    "type": bias_type,
+                    "severity": severity,
+                    "score": score,
+                    "description": f"{bias_type.capitalize()} bias detected based on keyword analysis and context"
+                })
+        
+        return {
+            "biasFlags_text": bias_flags,
+            "bias_scores": bias_scores,
+            "bias_details": bias_details,
+            "overall_bias_score": round(np.mean(list(bias_scores.values())), 3),
+            "analysis_timestamp": datetime.now().isoformat()
+        }
+    
+    # ========================================================================
+    # 2. RAG OUTPUT BIAS DETECTION
+    # ========================================================================
+    
+    def detect_rag_output_bias(self, 
+                               rag_summary: str, 
+                               source_documents: List[str]) -> Dict[str, Any]:
+        """
+        Detect bias in AI-generated RAG summaries/reasoning
+        
+        Args:
+            rag_summary: AI-generated summary or reasoning
+            source_documents: Original source documents used for RAG
+            
+        Returns:
+            Dict containing RAG-specific bias flags
+        """
+        bias_flags = []
+        bias_details = []
+        
+        # Get embeddings
+        summary_emb = self.get_embeddings(rag_summary)
+        source_embs = [self.get_embeddings(doc) for doc in source_documents[:5]]  # Limit to 5
+        
+        # 1. TONE BIAS - Check if summary tone differs from sources
+        if source_embs:
+            avg_source_emb = torch.mean(torch.stack(source_embs), dim=0)
+            # Cosine similarity
+            similarity = torch.nn.functional.cosine_similarity(summary_emb, avg_source_emb)
+            
+            if similarity < 0.7:  # Low similarity indicates tone shift
+                bias_flags.append("tone_bias")
+                bias_details.append({
+                    "type": "tone_bias",
+                    "severity": "medium",
+                    "score": round(1 - similarity.item(), 3),
+                    "description": "AI summary tone differs significantly from source documents"
+                })
+        
+        # 2. INTERPRETIVE BIAS - Check for subjective language
+        subjective_words = [
+            'clearly', 'obviously', 'undoubtedly', 'certainly', 'definitely',
+            'surely', 'apparently', 'seemingly', 'arguably', 'presumably'
+        ]
+        summary_lower = rag_summary.lower()
+        subjective_count = sum(summary_lower.count(word) for word in subjective_words)
+        
+        if subjective_count > 2:
+            bias_flags.append("interpretive_bias")
+            bias_details.append({
+                "type": "interpretive_bias",
+                "severity": "medium" if subjective_count > 4 else "low",
+                "score": round(min(subjective_count / 10, 1.0), 3),
+                "description": f"Summary contains {subjective_count} subjective/interpretive terms"
+            })
+        
+        # 3. SELECTIVITY BIAS - Check if summary over-represents certain aspects
+        # Count mentions of different legal aspects
+        aspects = {
+            'procedural': ['procedure', 'process', 'filing', 'hearing', 'appeal'],
+            'substantive': ['law', 'statute', 'provision', 'section', 'act'],
+            'factual': ['fact', 'evidence', 'witness', 'testimony', 'statement']
+        }
+        
+        aspect_counts = {k: sum(summary_lower.count(w) for w in v) for k, v in aspects.items()}
+        max_count = max(aspect_counts.values()) if aspect_counts.values() else 1
+        
+        if max_count > 5 and any(count < max_count * 0.3 for count in aspect_counts.values()):
+            bias_flags.append("selectivity_bias")
+            bias_details.append({
+                "type": "selectivity_bias",
+                "severity": "low",
+                "score": 0.4,
+                "description": "Summary may over-emphasize certain legal aspects"
+            })
+        
+        return {
+            "biasFlags_output": bias_flags,
+            "bias_details": bias_details,
+            "analysis_timestamp": datetime.now().isoformat()
+        }
+    
+    # ========================================================================
+    # 3. SYSTEMIC/STATISTICAL BIAS DETECTION
+    # ========================================================================
+    
+    def detect_systemic_bias(self, 
+                            historical_cases: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Analyze systemic and statistical biases from historical case data
+        
+        Args:
+            historical_cases: List of case dictionaries with keys:
+                - outcome: str (e.g., "conviction", "acquittal")
+                - gender: str (optional)
+                - region: str (optional)
+                - caste: str (optional)
+                - case_type: str
+                - year: int
+                
+        Returns:
+            Dict containing systemic bias metrics and dashboard data
+        """
+        if not historical_cases:
+            return {"error": "No historical cases provided"}
+        
+        # Initialize analytics
+        outcome_by_gender = {}
+        outcome_by_region = {}
+        outcome_by_caste = {}
+        outcome_by_year = {}
+        
+        # Process cases
+        for case in historical_cases:
+            outcome = case.get('outcome', 'unknown')
+            
+            # Gender analysis
+            if 'gender' in case:
+                gender = case['gender']
+                if gender not in outcome_by_gender:
+                    outcome_by_gender[gender] = []
+                outcome_by_gender[gender].append(outcome)
+            
+            # Region analysis
+            if 'region' in case:
+                region = case['region']
+                if region not in outcome_by_region:
+                    outcome_by_region[region] = []
+                outcome_by_region[region].append(outcome)
+            
+            # Caste analysis
+            if 'caste' in case:
+                caste = case['caste']
+                if caste not in outcome_by_caste:
+                    outcome_by_caste[caste] = []
+                outcome_by_caste[caste].append(outcome)
+            
+            # Temporal analysis
+            if 'year' in case:
+                year = case['year']
+                if year not in outcome_by_year:
+                    outcome_by_year[year] = []
+                outcome_by_year[year].append(outcome)
+        
+        # Calculate disparity metrics
+        def calculate_disparity(outcome_dict: Dict) -> Dict:
+            """Calculate outcome disparities"""
+            disparity_data = {}
+            for category, outcomes in outcome_dict.items():
+                total = len(outcomes)
+                if total > 0:
+                    conviction_rate = outcomes.count('conviction') / total
+                    disparity_data[category] = {
+                        'total_cases': total,
+                        'conviction_rate': round(conviction_rate, 3),
+                        'acquittal_rate': round(outcomes.count('acquittal') / total, 3)
+                    }
+            return disparity_data
+        
+        gender_disparity = calculate_disparity(outcome_by_gender)
+        region_disparity = calculate_disparity(outcome_by_region)
+        caste_disparity = calculate_disparity(outcome_by_caste)
+        
+        # Detect significant disparities
+        bias_flags = []
+        
+        if gender_disparity:
+            rates = [d['conviction_rate'] for d in gender_disparity.values()]
+            if max(rates) - min(rates) > 0.15:
+                bias_flags.append("gender_disparity")
+        
+        if region_disparity:
+            rates = [d['conviction_rate'] for d in region_disparity.values()]
+            if max(rates) - min(rates) > 0.15:
+                bias_flags.append("regional_disparity")
+        
+        if caste_disparity:
+            rates = [d['conviction_rate'] for d in caste_disparity.values()]
+            if max(rates) - min(rates) > 0.15:
+                bias_flags.append("caste_disparity")
+        
+        # Generate dashboard-ready data
+        dashboard_data = {
+            "summary_metrics": {
+                "total_cases_analyzed": len(historical_cases),
+                "overall_conviction_rate": round(
+                    sum(1 for c in historical_cases if c.get('outcome') == 'conviction') / len(historical_cases),
+                    3
+                ),
+                "bias_flags_detected": len(bias_flags)
+            },
+            "gender_analysis": {
+                "disparity_data": gender_disparity,
+                "chart_data": [
+                    {"category": k, "conviction_rate": v['conviction_rate']} 
+                    for k, v in gender_disparity.items()
+                ]
+            },
+            "regional_analysis": {
+                "disparity_data": region_disparity,
+                "chart_data": [
+                    {"category": k, "conviction_rate": v['conviction_rate']} 
+                    for k, v in region_disparity.items()
+                ]
+            },
+            "caste_analysis": {
+                "disparity_data": caste_disparity,
+                "chart_data": [
+                    {"category": k, "conviction_rate": v['conviction_rate']} 
+                    for k, v in caste_disparity.items()
+                ]
+            },
+            "temporal_trends": {
+                "by_year": {
+                    year: {
+                        'total': len(outcomes),
+                        'conviction_rate': round(outcomes.count('conviction') / len(outcomes), 3)
+                    }
+                    for year, outcomes in outcome_by_year.items()
+                }
+            }
+        }
+        
+        return {
+            "systemic_bias_flags": bias_flags,
+            "biasDashboardData": dashboard_data,
+            "analysis_timestamp": datetime.now().isoformat()
+        }
+    
+    # ========================================================================
+    # 4. OUTCOME PREDICTION
+    # ========================================================================
+    
+    def predict_outcome(self, 
+                       case_text: str,
+                       case_metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """
+        Predict legal case outcome using InLegalBERT embeddings and heuristics
+        
+        Args:
+            case_text: Full case text (FIR, facts, arguments, etc.)
+            case_metadata: Optional metadata (case_type, jurisdiction, etc.)
+            
+        Returns:
+            Dict containing prediction, confidence, and justification
+        """
+        # Get text embeddings
+        embeddings = self.get_embeddings(case_text)
+        
+        # Keyword-based prediction (simplified - in production use fine-tuned classifier)
+        conviction_keywords = [
+            'guilty', 'convicted', 'evidence proves', 'beyond reasonable doubt',
+            'establish', 'proven', 'corroborated', 'substantiated'
+        ]
+        acquittal_keywords = [
+            'not guilty', 'acquitted', 'benefit of doubt', 'insufficient evidence',
+            'failed to prove', 'contradictory', 'unreliable', 'doubt'
+        ]
+        
+        text_lower = case_text.lower()
+        conviction_score = sum(text_lower.count(kw) for kw in conviction_keywords)
+        acquittal_score = sum(text_lower.count(kw) for kw in acquittal_keywords)
+        
+        # Calculate prediction
+        total_score = conviction_score + acquittal_score
+        if total_score == 0:
+            # No strong indicators, use neutral prediction
+            predicted_outcome = "uncertain"
+            confidence_score = 0.5
+            justification = "Insufficient textual indicators for confident prediction"
+        else:
+            conviction_prob = conviction_score / total_score
+            
+            if conviction_prob > 0.6:
+                predicted_outcome = "conviction"
+                confidence_score = round(conviction_prob, 3)
+                justification = f"Text analysis shows {conviction_score} conviction indicators vs {acquittal_score} acquittal indicators"
+            elif conviction_prob < 0.4:
+                predicted_outcome = "acquittal"
+                confidence_score = round(1 - conviction_prob, 3)
+                justification = f"Text analysis shows {acquittal_score} acquittal indicators vs {conviction_score} conviction indicators"
+            else:
+                predicted_outcome = "uncertain"
+                confidence_score = 0.5
+                justification = "Mixed indicators suggest uncertain outcome"
+        
+        # Adjust for metadata if provided
+        if case_metadata:
+            case_type = case_metadata.get('case_type', '').lower()
+            
+            # Example adjustments (customize based on domain knowledge)
+            if 'bail' in case_type:
+                if predicted_outcome == "conviction":
+                    predicted_outcome = "bail_denied"
+                    justification += "; Bail application context considered"
+                elif predicted_outcome == "acquittal":
+                    predicted_outcome = "bail_granted"
+                    justification += "; Bail application context considered"
+        
+        # Confidence level categorization
+        if confidence_score >= 0.75:
+            confidence_level = "high"
+        elif confidence_score >= 0.5:
+            confidence_level = "medium"
+        else:
+            confidence_level = "low"
+        
+        return {
+            "predictedOutcome": predicted_outcome,
+            "confidenceScore": confidence_score,
+            "confidenceLevel": confidence_level,
+            "justification": justification,
+            "embedding_norm": float(torch.norm(embeddings).item()),
+            "analysis_timestamp": datetime.now().isoformat()
+        }
+
+# ============================================================================
+# API INTERFACE FUNCTIONS
+# ============================================================================
+
+# Global model instance (loaded once)
+_model_instance = None
+
+def get_model() -> InLegalBERTEngine:
+    """Get or create model instance (singleton pattern)"""
+    global _model_instance
+    if _model_instance is None:
+        _model_instance = InLegalBERTEngine()
+    return _model_instance
+
+
+def analyze_legal_case(
+    case_text: str,
+    rag_summary: Optional[str] = None,
+    source_documents: Optional[List[str]] = None,
+    historical_cases: Optional[List[Dict]] = None,
+    case_metadata: Optional[Dict] = None
+) -> Dict[str, Any]:
+    """
+    Main API function for comprehensive legal case analysis
+    
+    Args:
+        case_text: Legal document/FIR/judgment text
+        rag_summary: AI-generated summary (for RAG bias detection)
+        source_documents: Source docs used for RAG (for RAG bias detection)
+        historical_cases: Historical case data (for systemic bias analysis)
+        case_metadata: Case metadata for outcome prediction
+        
+    Returns:
+        JSON-serializable dict with all analysis results
+    """
+    model = get_model()
+    
+    results = {
+        "status": "success",
+        "analysis_id": f"analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
+        "timestamp": datetime.now().isoformat()
+    }
+    
+    # 1. Document bias detection
+    if case_text:
+        results["document_bias"] = model.detect_document_bias(case_text)
+    
+    # 2. RAG output bias detection
+    if rag_summary and source_documents:
+        results["rag_bias"] = model.detect_rag_output_bias(rag_summary, source_documents)
+    
+    # 3. Systemic bias analysis
+    if historical_cases:
+        results["systemic_bias"] = model.detect_systemic_bias(historical_cases)
+    
+    # 4. Outcome prediction
+    if case_text:
+        results["outcome_prediction"] = model.predict_outcome(case_text, case_metadata)
+    
+    return results
+
+
+# ============================================================================
+# EXAMPLE USAGE
+# ============================================================================
+
+if __name__ == "__main__":
+    # Example legal case text
+    sample_case = """
+    The accused, a 35-year-old woman from rural Maharashtra, was charged under 
+    Section 302 IPC for alleged murder. The prosecution's case relies heavily on 
+    circumstantial evidence. The witness testimonies are contradictory, and the 
+    forensic evidence is inconclusive. The accused belongs to a scheduled caste 
+    community. The defense argues that there is insufficient evidence to establish 
+    guilt beyond reasonable doubt.
+    """
+    
+    # Example RAG summary
+    sample_rag_summary = """
+    Clearly, the evidence points toward acquittal. The case obviously lacks 
+    substantial proof of guilt.
+    """
+    
+    # Example historical cases
+    sample_historical = [
+        {"outcome": "conviction", "gender": "male", "region": "urban", "year": 2020},
+        {"outcome": "acquittal", "gender": "female", "region": "rural", "year": 2020},
+        {"outcome": "conviction", "gender": "male", "region": "urban", "year": 2021},
+        {"outcome": "conviction", "gender": "female", "region": "urban", "year": 2021},
+    ]
+    
+    # Run comprehensive analysis
+    print("Running comprehensive legal analysis...\n")
+    results = analyze_legal_case(
+        case_text=sample_case,
+        rag_summary=sample_rag_summary,
+        source_documents=[sample_case],
+        historical_cases=sample_historical,
+        case_metadata={"case_type": "criminal", "jurisdiction": "Maharashtra"}
+    )
+    
+    # Print results
+    print(json.dumps(results, indent=2))
+

document_generator.py

@@ -0,0 +1,465 @@
+"""
+Legal Document Generator for LexAI
+==================================
+
+Quick MVP for hackathon demo
+Generates bail applications, FIR drafts, and legal notices
+"""
+
+from typing import Dict, Any, Optional
+from datetime import datetime
+import json
+
+class LegalDocumentGenerator:
+    """
+    Generate legal documents from templates with AI assistance
+    """
+    
+    def __init__(self):
+        self.templates = self._load_templates()
+    
+    def _load_templates(self) -> Dict[str, str]:
+        """Load document templates"""
+        return {
+            'bail_application': """
+IN THE COURT OF {court_name}
+
+CRIMINAL MISCELLANEOUS APPLICATION NO. _______
+
+IN THE MATTER OF:
+{applicant_name} ... Applicant
+(Through Advocate: {advocate_name})
+
+VERSUS
+
+STATE OF {state} ... Respondent
+
+APPLICATION FOR BAIL UNDER SECTION {section}
+
+RESPECTFULLY SHOWETH:
+
+1. That the applicant is an accused in FIR No. {fir_number} dated {fir_date} registered at Police Station {police_station} under Sections {charges} of the Indian Penal Code.
+
+2. That the applicant was arrested on {arrest_date} and has been in judicial custody since then.
+
+3. That the applicant is {age} years old, a resident of {address}, and is {occupation} by profession.
+
+4. That the applicant is {family_status} and is the sole bread earner of the family.
+
+5. That the applicant has deep roots in the community and has no criminal antecedents.
+
+6. GROUNDS FOR BAIL:
+
+{grounds}
+
+7. That the applicant undertakes to:
+   a) Appear before the Court as and when required
+   b) Not tamper with evidence or influence witnesses
+   c) Not commit any offense while on bail
+   d) Furnish personal or surety bond as required
+
+8. That the applicant is willing to comply with any conditions that this Hon'ble Court may deem fit to impose.
+
+PRAYER:
+
+In view of the above, it is most respectfully prayed that this Hon'ble Court may be pleased to:
+
+a) Grant bail to the applicant
+b) Pass any other order as deemed fit in the interest of justice
+
+Place: {place}
+Date: {date}
+
+                                        (Advocate for Applicant)
+""",
+
+            'fir_complaint': """
+FIRST INFORMATION REPORT (FIR)
+
+Police Station: {police_station}
+District: {district}
+Date: {date}
+Time: {time}
+
+COMPLAINANT DETAILS:
+Name: {complainant_name}
+Father's/Husband's Name: {father_husband_name}
+Address: {address}
+Contact Number: {phone}
+Email: {email}
+
+ACCUSED DETAILS:
+{accused_details}
+
+DETAILS OF INCIDENT:
+
+1. Date and Time of Incident: {incident_date} at approximately {incident_time}
+
+2. Place of Incident: {incident_place}
+
+3. Description of Incident:
+
+{incident_description}
+
+4. Details of Loss/Injury (if any):
+
+{loss_details}
+
+5. Witnesses (if any):
+
+{witnesses}
+
+6. Evidence Available:
+
+{evidence}
+
+7. Sections Applicable:
+
+Based on the facts narrated above, it appears that offenses under the following sections have been committed:
+{sections_applicable}
+
+8. I hereby declare that the above information is true to the best of my knowledge and belief.
+
+Signature of Complainant: _______________
+Name: {complainant_name}
+Date: {date}
+
+[For Official Use Only]
+FIR No.: _____________
+Registered under Sections: _____________
+Investigating Officer: _____________
+""",
+
+            'legal_notice': """
+LEGAL NOTICE
+
+To,
+{recipient_name}
+{recipient_address}
+
+Date: {date}
+
+Dear Sir/Madam,
+
+SUBJECT: LEGAL NOTICE UNDER {act_section}
+
+Under instructions from and on behalf of my client, {client_name}, residing at {client_address}, I hereby serve you with this legal notice for the following reasons:
+
+1. FACTS OF THE CASE:
+
+{case_facts}
+
+2. CAUSE OF ACTION:
+
+{cause_of_action}
+
+3. LEGAL GROUNDS:
+
+The acts/omissions on your part constitute violations under:
+{legal_grounds}
+
+4. RELIEF SOUGHT:
+
+My client demands that you:
+
+{relief_demanded}
+
+5. NOTICE PERIOD:
+
+You are hereby called upon to comply with the above demands within 15 days from the date of receipt of this notice, failing which my client shall be constrained to initiate appropriate legal proceedings against you at your risk as to costs and consequences.
+
+This notice is without prejudice to the rights and contentions of my client.
+
+Yours faithfully,
+
+{advocate_name}
+Advocate for {client_name}
+Address: {advocate_address}
+Contact: {advocate_contact}
+""",
+
+            'petition': """
+IN THE {court_name}
+
+{petition_type} PETITION NO. _______
+
+IN THE MATTER OF:
+
+{petitioner_name}
+{petitioner_address}
+... Petitioner
+
+VERSUS
+
+{respondent_name}
+{respondent_address}
+... Respondent
+
+PETITION UNDER {under_section}
+
+TO,
+THE HON'BLE {judge_title}
+
+THE HUMBLE PETITION OF THE PETITIONER ABOVE-NAMED
+
+MOST RESPECTFULLY SHOWETH:
+
+1. PARTIES:
+
+{parties_description}
+
+2. FACTS:
+
+{facts}
+
+3. CAUSE OF ACTION:
+
+{cause_of_action}
+
+4. GROUNDS:
+
+{grounds}
+
+5. RELIEF:
+
+WHEREFORE, in the light of the facts and circumstances stated above, it is most respectfully prayed that this Hon'ble Court may be pleased to:
+
+{relief_prayed}
+
+And pass such other and further orders as this Hon'ble Court may deem fit and proper in the interest of justice.
+
+Place: {place}
+Date: {date}
+
+                                        PETITIONER/ADVOCATE
+"""
+        }
+    
+    def generate_bail_application(self, details: Dict[str, Any]) -> Dict[str, str]:
+        """
+        Generate bail application
+        
+        Args:
+            details: Dict containing applicant details, charges, grounds, etc.
+        """
+        template = self.templates['bail_application']
+        
+        # Set defaults
+        doc_details = {
+            'court_name': details.get('court_name', 'SESSIONS JUDGE'),
+            'applicant_name': details.get('applicant_name', '[APPLICANT NAME]'),
+            'advocate_name': details.get('advocate_name', '[ADVOCATE NAME]'),
+            'state': details.get('state', '[STATE]'),
+            'section': details.get('section', '439 Cr.P.C.'),
+            'fir_number': details.get('fir_number', '[FIR NO.]'),
+            'fir_date': details.get('fir_date', '[DATE]'),
+            'police_station': details.get('police_station', '[POLICE STATION]'),
+            'charges': details.get('charges', '[IPC SECTIONS]'),
+            'arrest_date': details.get('arrest_date', '[ARREST DATE]'),
+            'age': details.get('age', '[AGE]'),
+            'address': details.get('address', '[ADDRESS]'),
+            'occupation': details.get('occupation', 'engaged in lawful occupation'),
+            'family_status': details.get('family_status', 'having family responsibilities'),
+            'grounds': self._generate_bail_grounds(details),
+            'place': details.get('place', '[PLACE]'),
+            'date': details.get('date', datetime.now().strftime('%d.%m.%Y')),
+        }
+        
+        document = template.format(**doc_details)
+        
+        return {
+            'document_type': 'bail_application',
+            'content': document,
+            'generated_at': datetime.now().isoformat(),
+            'editable': True,
+            'format': 'text/plain'
+        }
+    
+    def _generate_bail_grounds(self, details: Dict[str, Any]) -> str:
+        """Auto-generate bail grounds based on details"""
+        grounds = []
+        
+        if details.get('first_time_offender', True):
+            grounds.append("a) The applicant is a first-time offender with no criminal antecedents.")
+        
+        if details.get('cooperating', True):
+            grounds.append("b) The applicant has been fully cooperating with the investigation.")
+        
+        if details.get('weak_evidence', False):
+            grounds.append("c) The evidence against the applicant is weak and based on circumstantial factors.")
+        
+        if details.get('no_flight_risk', True):
+            grounds.append("d) The applicant has deep roots in the community and there is no risk of absconding.")
+        
+        if details.get('medical_grounds', False):
+            grounds.append("e) The applicant requires medical attention which cannot be adequately provided in custody.")
+        
+        grounds.append("f) The applicant's continued detention is not necessary for the purpose of investigation.")
+        grounds.append("g) The applicant is willing to abide by any conditions imposed by this Hon'ble Court.")
+        
+        return '\n   '.join(grounds)
+    
+    def generate_fir(self, details: Dict[str, Any]) -> Dict[str, str]:
+        """Generate FIR/Complaint"""
+        template = self.templates['fir_complaint']
+        
+        doc_details = {
+            'police_station': details.get('police_station', '[POLICE STATION]'),
+            'district': details.get('district', '[DISTRICT]'),
+            'date': details.get('date', datetime.now().strftime('%d.%m.%Y')),
+            'time': details.get('time', datetime.now().strftime('%H:%M')),
+            'complainant_name': details.get('complainant_name', '[NAME]'),
+            'father_husband_name': details.get('father_husband_name', '[FATHER/HUSBAND NAME]'),
+            'address': details.get('address', '[ADDRESS]'),
+            'phone': details.get('phone', '[PHONE]'),
+            'email': details.get('email', '[EMAIL]'),
+            'accused_details': details.get('accused_details', '[ACCUSED DETAILS]'),
+            'incident_date': details.get('incident_date', '[DATE]'),
+            'incident_time': details.get('incident_time', '[TIME]'),
+            'incident_place': details.get('incident_place', '[PLACE]'),
+            'incident_description': details.get('incident_description', '[DESCRIPTION OF INCIDENT]'),
+            'loss_details': details.get('loss_details', 'N/A'),
+            'witnesses': details.get('witnesses', 'None'),
+            'evidence': details.get('evidence', 'As per investigation'),
+            'sections_applicable': details.get('sections_applicable', '[IPC SECTIONS]'),
+        }
+        
+        document = template.format(**doc_details)
+        
+        return {
+            'document_type': 'fir_complaint',
+            'content': document,
+            'generated_at': datetime.now().isoformat(),
+            'editable': True,
+            'format': 'text/plain'
+        }
+    
+    def generate_legal_notice(self, details: Dict[str, Any]) -> Dict[str, str]:
+        """Generate legal notice"""
+        template = self.templates['legal_notice']
+        
+        doc_details = {
+            'date': details.get('date', datetime.now().strftime('%d.%m.%Y')),
+            'recipient_name': details.get('recipient_name', '[RECIPIENT NAME]'),
+            'recipient_address': details.get('recipient_address', '[RECIPIENT ADDRESS]'),
+            'act_section': details.get('act_section', 'RELEVANT PROVISIONS'),
+            'client_name': details.get('client_name', '[CLIENT NAME]'),
+            'client_address': details.get('client_address', '[CLIENT ADDRESS]'),
+            'case_facts': details.get('case_facts', '[FACTS OF THE CASE]'),
+            'cause_of_action': details.get('cause_of_action', '[CAUSE OF ACTION]'),
+            'legal_grounds': details.get('legal_grounds', '[LEGAL VIOLATIONS]'),
+            'relief_demanded': details.get('relief_demanded', '[RELIEF SOUGHT]'),
+            'advocate_name': details.get('advocate_name', '[ADVOCATE NAME]'),
+            'advocate_address': details.get('advocate_address', '[ADVOCATE ADDRESS]'),
+            'advocate_contact': details.get('advocate_contact', '[CONTACT]'),
+        }
+        
+        document = template.format(**doc_details)
+        
+        return {
+            'document_type': 'legal_notice',
+            'content': document,
+            'generated_at': datetime.now().isoformat(),
+            'editable': True,
+            'format': 'text/plain'
+        }
+    
+    def generate_petition(self, details: Dict[str, Any]) -> Dict[str, str]:
+        """Generate petition"""
+        template = self.templates['petition']
+        
+        doc_details = {
+            'court_name': details.get('court_name', 'HIGH COURT OF [STATE]'),
+            'petition_type': details.get('petition_type', 'WRIT'),
+            'petitioner_name': details.get('petitioner_name', '[PETITIONER]'),
+            'petitioner_address': details.get('petitioner_address', '[ADDRESS]'),
+            'respondent_name': details.get('respondent_name', '[RESPONDENT]'),
+            'respondent_address': details.get('respondent_address', '[ADDRESS]'),
+            'under_section': details.get('under_section', 'ARTICLE 226 OF THE CONSTITUTION'),
+            'judge_title': details.get('judge_title', 'CHIEF JUSTICE AND HIS COMPANION JUDGES'),
+            'parties_description': details.get('parties_description', '[PARTY DETAILS]'),
+            'facts': details.get('facts', '[FACTS]'),
+            'cause_of_action': details.get('cause_of_action', '[CAUSE OF ACTION]'),
+            'grounds': details.get('grounds', '[GROUNDS]'),
+            'relief_prayed': details.get('relief_prayed', '[RELIEF PRAYED]'),
+            'place': details.get('place', '[PLACE]'),
+            'date': details.get('date', datetime.now().strftime('%d.%m.%Y')),
+        }
+        
+        document = template.format(**doc_details)
+        
+        return {
+            'document_type': 'petition',
+            'content': document,
+            'generated_at': datetime.now().isoformat(),
+            'editable': True,
+            'format': 'text/plain'
+        }
+    
+    def get_template_list(self) -> list:
+        """Get list of available templates"""
+        return [
+            {
+                'id': 'bail_application',
+                'name': 'Bail Application',
+                'description': 'Application for bail under CrPC Section 439',
+                'category': 'Criminal'
+            },
+            {
+                'id': 'fir_complaint',
+                'name': 'FIR / Complaint',
+                'description': 'First Information Report for filing with police',
+                'category': 'Criminal'
+            },
+            {
+                'id': 'legal_notice',
+                'name': 'Legal Notice',
+                'description': 'Legal notice under relevant provisions',
+                'category': 'General'
+            },
+            {
+                'id': 'petition',
+                'name': 'Petition',
+                'description': 'Writ petition or other court petition',
+                'category': 'Civil/Writ'
+            }
+        ]
+
+
+# Global instance
+_doc_generator = None
+
+def get_document_generator() -> LegalDocumentGenerator:
+    """Get or create document generator instance"""
+    global _doc_generator
+    if _doc_generator is None:
+        _doc_generator = LegalDocumentGenerator()
+    return _doc_generator
+
+
+# Test
+if __name__ == "__main__":
+    generator = LegalDocumentGenerator()
+    
+    # Test bail application
+    print("Generating bail application...")
+    bail_details = {
+        'applicant_name': 'Rajesh Kumar',
+        'advocate_name': 'Adv. Priya Sharma',
+        'state': 'Delhi',
+        'fir_number': '123/2024',
+        'fir_date': '15.01.2024',
+        'police_station': 'Connaught Place',
+        'charges': '420, 468 IPC',
+        'arrest_date': '16.01.2024',
+        'age': '35',
+        'address': '123, New Delhi',
+        'first_time_offender': True,
+        'no_flight_risk': True,
+    }
+    
+    result = generator.generate_bail_application(bail_details)
+    print(result['content'][:500] + "...")
+    print(f"\nDocument type: {result['document_type']}")
+    print(f"Generated at: {result['generated_at']}")
+

requirements.txt

@@ -0,0 +1,27 @@
+# InLegalBERT Bias Detection & Outcome Prediction Dependencies
+# ============================================================
+
+# Core ML/AI Libraries
+torch>=2.0.0
+transformers>=4.35.0
+sentence-transformers>=2.2.0
+
+# API Framework
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+pydantic>=2.0.0
+
+# Data Processing
+numpy>=1.24.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+
+# Utilities
+python-multipart>=0.0.6
+python-dotenv>=1.0.0
+requests>=2.31.0
+
+# Hackathon Features
+googletrans==4.0.0rc1
+langdetect>=1.0.9
+

simulation_engine.py

@@ -0,0 +1,326 @@
+"""
+What-If Simulation Engine for LexAI
+===================================
+
+Hackathon MVP - Interactive case outcome simulation
+Shows how changes in case facts affect predictions
+"""
+
+from typing import Dict, Any, List, Optional
+import re
+from bias_prediction_engine import get_model
+
+class SimulationEngine:
+    """
+    Simulate legal case outcomes with modified facts
+    """
+    
+    def __init__(self):
+        self.ml_model = get_model()
+        
+        # Modifiable factors and their impacts
+        self.factor_impacts = {
+            'prior_conviction': {
+                'weight': 0.25,
+                'direction': 'negative',
+                'description': 'Previous criminal record'
+            },
+            'witness_credibility': {
+                'weight': 0.20,
+                'direction': 'positive',
+                'description': 'Reliability of witnesses'
+            },
+            'evidence_quality': {
+                'weight': 0.30,
+                'direction': 'positive',
+                'description': 'Strength of evidence'
+            },
+            'mitigating_factors': {
+                'weight': 0.15,
+                'direction': 'positive',
+                'description': 'Circumstances favoring accused'
+            },
+            'flight_risk': {
+                'weight': 0.10,
+                'direction': 'negative',
+                'description': 'Risk of absconding'
+            }
+        }
+    
+    def simulate_outcome(self, 
+                        base_case: Dict[str, Any], 
+                        modifications: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Simulate how case outcome changes with modifications
+        
+        Args:
+            base_case: Original case facts
+            modifications: Changes to apply
+            
+        Returns:
+            Comparison of outcomes
+        """
+        
+        # Get base prediction
+        base_text = base_case.get('facts', '')
+        base_prediction = self.ml_model.predict_outcome(
+            base_text,
+            base_case.get('metadata', {})
+        )
+        
+        # Apply modifications
+        modified_text = self._apply_modifications(base_text, modifications)
+        modified_prediction = self.ml_model.predict_outcome(
+            modified_text,
+            base_case.get('metadata', {})
+        )
+        
+        # Calculate impact
+        impact_analysis = self._analyze_impact(
+            base_prediction,
+            modified_prediction,
+            modifications
+        )
+        
+        return {
+            'base_case': {
+                'facts': base_text,
+                'prediction': base_prediction
+            },
+            'modified_case': {
+                'facts': modified_text,
+                'prediction': modified_prediction,
+                'changes_applied': list(modifications.keys())
+            },
+            'impact_analysis': impact_analysis,
+            'visualization_data': self._generate_viz_data(
+                base_prediction,
+                modified_prediction
+            )
+        }
+    
+    def _apply_modifications(self, base_text: str, modifications: Dict[str, Any]) -> str:
+        """Apply modifications to case facts"""
+        modified = base_text
+        
+        # Remove prior conviction if specified
+        if modifications.get('remove_prior_conviction'):
+            modified = re.sub(
+                r'(prior conviction|criminal record|previous offense).*?\.', 
+                'has no prior criminal record.', 
+                modified, 
+                flags=re.IGNORECASE
+            )
+        
+        # Add strong alibi
+        if modifications.get('add_strong_alibi'):
+            modified += " The accused has a strong alibi with multiple credible witnesses confirming their presence elsewhere during the incident."
+        
+        # Improve witness credibility
+        if modifications.get('improve_witness_credibility'):
+            modified = re.sub(
+                r'(witness.*?)(contradictory|unreliable|questionable)',
+                r'\1credible and consistent',
+                modified,
+                flags=re.IGNORECASE
+            )
+        
+        # Add mitigating factors
+        if modifications.get('add_mitigating_factors'):
+            mitigating = modifications['add_mitigating_factors']
+            modified += f" {mitigating}"
+        
+        # Reduce flight risk
+        if modifications.get('reduce_flight_risk'):
+            modified += " The accused has deep roots in the community, stable employment, and family responsibilities, eliminating any flight risk."
+        
+        # Enhance evidence quality
+        if modifications.get('enhance_evidence'):
+            modified = re.sub(
+                r'(evidence.*?)(weak|insufficient|circumstantial)',
+                r'\1strong and conclusive',
+                modified,
+                flags=re.IGNORECASE
+            )
+        
+        return modified
+    
+    def _analyze_impact(self, 
+                       base_pred: Dict, 
+                       modified_pred: Dict,
+                       modifications: Dict) -> Dict[str, Any]:
+        """Analyze impact of modifications"""
+        
+        confidence_change = modified_pred['confidenceScore'] - base_pred['confidenceScore']
+        outcome_changed = base_pred['predictedOutcome'] != modified_pred['predictedOutcome']
+        
+        # Calculate factor contributions
+        factor_impacts = []
+        for mod_key, mod_value in modifications.items():
+            if mod_value:  # If modification was applied
+                factor_name = mod_key.replace('_', ' ').title()
+                estimated_impact = self._estimate_factor_impact(mod_key)
+                factor_impacts.append({
+                    'factor': factor_name,
+                    'estimated_impact': estimated_impact,
+                    'direction': 'positive' if estimated_impact > 0 else 'negative'
+                })
+        
+        return {
+            'outcome_changed': outcome_changed,
+            'confidence_change': round(confidence_change, 3),
+            'confidence_change_percent': round(confidence_change * 100, 1),
+            'factor_contributions': factor_impacts,
+            'key_factors': self._identify_key_factors(modifications),
+            'recommendation': self._generate_recommendation(
+                base_pred,
+                modified_pred,
+                outcome_changed
+            )
+        }
+    
+    def _estimate_factor_impact(self, factor_key: str) -> float:
+        """Estimate impact of a specific factor"""
+        impact_map = {
+            'remove_prior_conviction': 0.25,
+            'add_strong_alibi': 0.30,
+            'improve_witness_credibility': 0.20,
+            'add_mitigating_factors': 0.15,
+            'reduce_flight_risk': 0.10,
+            'enhance_evidence': 0.35,
+        }
+        return impact_map.get(factor_key, 0.10)
+    
+    def _identify_key_factors(self, modifications: Dict) -> List[str]:
+        """Identify most impactful factors"""
+        applied_mods = [k for k, v in modifications.items() if v]
+        impacts = [(mod, self._estimate_factor_impact(mod)) for mod in applied_mods]
+        impacts.sort(key=lambda x: x[1], reverse=True)
+        return [mod.replace('_', ' ').title() for mod, _ in impacts[:3]]
+    
+    def _generate_recommendation(self, 
+                                 base_pred: Dict,
+                                 modified_pred: Dict,
+                                 outcome_changed: bool) -> str:
+        """Generate recommendation based on simulation"""
+        if outcome_changed:
+            return f"Modifying the specified factors could change the outcome from {base_pred['predictedOutcome']} to {modified_pred['predictedOutcome']}. These factors should be given priority in case preparation."
+        else:
+            conf_diff = abs(modified_pred['confidenceScore'] - base_pred['confidenceScore'])
+            if conf_diff > 0.15:
+                return f"While the outcome remains {base_pred['predictedOutcome']}, the confidence has changed by {round(conf_diff * 100, 1)}%. These factors significantly influence case strength."
+            else:
+                return "The modifications have minimal impact on the outcome. Other factors may be more critical to case success."
+    
+    def _generate_viz_data(self, base_pred: Dict, modified_pred: Dict) -> Dict:
+        """Generate data for visualization"""
+        return {
+            'confidence_comparison': {
+                'base': round(base_pred['confidenceScore'] * 100, 1),
+                'modified': round(modified_pred['confidenceScore'] * 100, 1),
+                'change': round((modified_pred['confidenceScore'] - base_pred['confidenceScore']) * 100, 1)
+            },
+            'outcome_labels': {
+                'base': base_pred['predictedOutcome'],
+                'modified': modified_pred['predictedOutcome']
+            },
+            'chart_type': 'bar_comparison',
+            'color_scheme': {
+                'base': '#6366f1',  # Indigo
+                'modified': '#10b981'  # Green
+            }
+        }
+    
+    def sensitivity_analysis(self, case_facts: str) -> Dict[str, Any]:
+        """
+        Analyze sensitivity to different factors
+        
+        Tests each factor independently to see impact
+        """
+        base_prediction = self.ml_model.predict_outcome(case_facts, {})
+        
+        sensitivity_results = []
+        
+        # Test each modification independently
+        test_modifications = [
+            {'remove_prior_conviction': True},
+            {'add_strong_alibi': True},
+            {'improve_witness_credibility': True},
+            {'add_mitigating_factors': 'First-time offender with family responsibilities'},
+            {'reduce_flight_risk': True},
+        ]
+        
+        for mod in test_modifications:
+            result = self.simulate_outcome(
+                {'facts': case_facts},
+                mod
+            )
+            
+            mod_name = list(mod.keys())[0].replace('_', ' ').title()
+            sensitivity_results.append({
+                'factor': mod_name,
+                'confidence_impact': result['impact_analysis']['confidence_change'],
+                'outcome_change': result['impact_analysis']['outcome_changed'],
+                'new_outcome': result['modified_case']['prediction']['predictedOutcome']
+            })
+        
+        # Sort by impact
+        sensitivity_results.sort(
+            key=lambda x: abs(x['confidence_impact']),
+            reverse=True
+        )
+        
+        return {
+            'base_outcome': base_prediction['predictedOutcome'],
+            'base_confidence': base_prediction['confidenceScore'],
+            'sensitivity_analysis': sensitivity_results,
+            'most_influential_factor': sensitivity_results[0]['factor'] if sensitivity_results else None,
+            'visualization_ready': True
+        }
+
+
+# Global instance
+_simulation_engine = None
+
+def get_simulation_engine() -> SimulationEngine:
+    """Get or create simulation engine instance"""
+    global _simulation_engine
+    if _simulation_engine is None:
+        _simulation_engine = SimulationEngine()
+    return _simulation_engine
+
+
+# Test
+if __name__ == "__main__":
+    engine = SimulationEngine()
+    
+    # Test case
+    base_case = {
+        'facts': """
+        The accused has prior conviction for theft. Witnesses gave contradictory statements.
+        Evidence is largely circumstantial. The accused attempted to flee when arrested.
+        """,
+        'metadata': {'case_type': 'criminal'}
+    }
+    
+    # Test modifications
+    modifications = {
+        'remove_prior_conviction': True,
+        'add_strong_alibi': True,
+        'improve_witness_credibility': True,
+    }
+    
+    print("Running simulation...")
+    result = engine.simulate_outcome(base_case, modifications)
+    
+    print(f"\nBase Outcome: {result['base_case']['prediction']['predictedOutcome']}")
+    print(f"Base Confidence: {result['base_case']['prediction']['confidenceScore']}")
+    
+    print(f"\nModified Outcome: {result['modified_case']['prediction']['predictedOutcome']}")
+    print(f"Modified Confidence: {result['modified_case']['prediction']['confidenceScore']}")
+    
+    print(f"\nOutcome Changed: {result['impact_analysis']['outcome_changed']}")
+    print(f"Confidence Change: {result['impact_analysis']['confidence_change_percent']}%")
+    print(f"Key Factors: {', '.join(result['impact_analysis']['key_factors'])}")
+    print(f"\nRecommendation: {result['impact_analysis']['recommendation']}")
+

translation_service.py

@@ -0,0 +1,201 @@
+"""
+Multilingual Translation Service for LexAI
+==========================================
+
+Quick MVP implementation for hackathon demo
+Supports translation between English and Indian regional languages
+"""
+
+from typing import Dict, Any, Optional
+from googletrans import Translator
+import re
+
+class MultilingualService:
+    """
+    Translate legal content between English and regional languages
+    """
+    
+    # Language codes
+    LANGUAGES = {
+        'en': 'English',
+        'hi': 'Hindi',
+        'ta': 'Tamil',
+        'te': 'Telugu',
+        'bn': 'Bengali',
+        'mr': 'Marathi',
+        'gu': 'Gujarati',
+        'kn': 'Kannada',
+        'ml': 'Malayalam',
+    }
+    
+    def __init__(self):
+        self.translator = Translator()
+        
+    def detect_language(self, text: str) -> str:
+        """Auto-detect language of input text"""
+        try:
+            detected = self.translator.detect(text)
+            return detected.lang
+        except:
+            return 'en'
+    
+    def translate_query(self, text: str, source_lang: str = 'auto', target_lang: str = 'en') -> Dict[str, Any]:
+        """
+        Translate user query to English for processing
+        
+        Args:
+            text: User query in regional language
+            source_lang: Source language code (auto-detect if 'auto')
+            target_lang: Target language (default: English)
+            
+        Returns:
+            Dict with translated text and metadata
+        """
+        try:
+            # Auto-detect if needed
+            if source_lang == 'auto':
+                source_lang = self.detect_language(text)
+            
+            # Translate
+            result = self.translator.translate(text, src=source_lang, dest=target_lang)
+            
+            return {
+                "original_text": text,
+                "translated_text": result.text,
+                "source_language": source_lang,
+                "source_language_name": self.LANGUAGES.get(source_lang, "Unknown"),
+                "target_language": target_lang,
+                "confidence": 0.95  # Mock confidence for demo
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "original_text": text,
+                "translated_text": text,  # Fallback to original
+                "source_language": source_lang,
+                "target_language": target_lang
+            }
+    
+    def translate_response(self, text: str, target_lang: str = 'hi') -> Dict[str, Any]:
+        """
+        Translate AI response to user's preferred language
+        
+        Args:
+            text: AI response in English
+            target_lang: User's preferred language
+            
+        Returns:
+            Dict with translated response
+        """
+        try:
+            result = self.translator.translate(text, src='en', dest=target_lang)
+            
+            return {
+                "original_text": text,
+                "translated_text": result.text,
+                "target_language": target_lang,
+                "target_language_name": self.LANGUAGES.get(target_lang, "Unknown"),
+            }
+        except Exception as e:
+            return {
+                "error": str(e),
+                "original_text": text,
+                "translated_text": text,
+                "target_language": target_lang
+            }
+    
+    def translate_legal_document(self, text: str, target_lang: str) -> str:
+        """Translate legal document preserving structure"""
+        try:
+            result = self.translator.translate(text, src='en', dest=target_lang)
+            return result.text
+        except:
+            return text
+    
+    def get_supported_languages(self) -> Dict[str, str]:
+        """Return list of supported languages"""
+        return self.LANGUAGES
+    
+    def simplify_legal_text(self, legal_text: str, reading_level: str = 'simple') -> Dict[str, Any]:
+        """
+        Convert complex legal language to plain language
+        
+        Args:
+            legal_text: Complex legal text
+            reading_level: 'simple' or 'intermediate'
+            
+        Returns:
+            Simplified text with explanations
+        """
+        
+        # Legal term mappings (MVP - can be expanded)
+        legal_simplifications = {
+            r'\binter alia\b': 'among other things',
+            r'\bres ipsa loquitur\b': 'the thing speaks for itself',
+            r'\bper se\b': 'by itself',
+            r'\bpro bono\b': 'for free',
+            r'\bhabeas corpus\b': 'produce the person (bring before court)',
+            r'\bbail\b': 'temporary release from custody',
+            r'\bFIR\b': 'First Information Report (initial police complaint)',
+            r'\bIPC\b': 'Indian Penal Code (criminal law)',
+            r'\bCrPC\b': 'Criminal Procedure Code (how criminal cases work)',
+            r'\bappellant\b': 'person appealing the decision',
+            r'\brespondent\b': 'person responding to appeal',
+            r'\bpetitioner\b': 'person filing the case',
+            r'\bdefendant\b': 'person accused/sued',
+            r'\bplaintiff\b': 'person filing complaint',
+            r'\bbeyond reasonable doubt\b': 'very certain, no significant doubts',
+            r'\bprecedent\b': 'previous similar case decision',
+            r'\bjurisdiction\b': 'legal authority/area of court',
+            r'\bconviction\b': 'found guilty',
+            r'\bacquittal\b': 'found not guilty',
+        }
+        
+        simplified = legal_text
+        
+        # Apply simplifications
+        for pattern, replacement in legal_simplifications.items():
+            simplified = re.sub(pattern, replacement, simplified, flags=re.IGNORECASE)
+        
+        # Extract key points (simple sentence extraction)
+        sentences = simplified.split('.')
+        key_points = [s.strip() + '.' for s in sentences if len(s.strip()) > 20][:5]
+        
+        return {
+            "original_text": legal_text,
+            "simplified_text": simplified,
+            "reading_level": reading_level,
+            "key_points": key_points,
+            "legal_terms_explained": list(legal_simplifications.values())[:10],
+            "summary": f"This text explains legal matters in simpler terms. {len(key_points)} key points identified."
+        }
+
+
+# Global instance
+_translation_service = None
+
+def get_translation_service() -> MultilingualService:
+    """Get or create translation service instance"""
+    global _translation_service
+    if _translation_service is None:
+        _translation_service = MultilingualService()
+    return _translation_service
+
+
+# Quick test
+if __name__ == "__main__":
+    service = MultilingualService()
+    
+    # Test translation
+    print("Testing translation...")
+    result = service.translate_query("मुझे जमानत कैसे मिलेगी?", source_lang='hi', target_lang='en')
+    print(f"Hindi → English: {result['translated_text']}")
+    
+    # Test simplification
+    print("\nTesting simplification...")
+    legal_text = "The appellant filed a habeas corpus petition seeking bail under Section 302 IPC. The FIR was lodged inter alia alleging murder beyond reasonable doubt."
+    simplified = service.simplify_legal_text(legal_text)
+    print(f"Original: {legal_text}")
+    print(f"Simplified: {simplified['simplified_text']}")
+    print(f"Key points: {simplified['key_points']}")
+