Update app.py

app.py

@@ -10,21 +10,19 @@ from groq import Groq
 import os
 from typing import List, Dict, Optional
 import logging
+import httpx
 
-# Configure logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Initialize FastAPI app
 app = FastAPI(
     title="LexNepal AI API",
-    description="Advanced Legal Intelligence API for Nepal Legal Code using RAG",
+    description="Advanced Legal Intelligence API for Nepal Legal Code",
     version="1.0.0",
     docs_url="/",
     redoc_url="/redoc"
 )
 
-# CORS middleware
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -33,7 +31,6 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Pydantic models
 class QueryRequest(BaseModel):
     query: str
     max_sources: Optional[int] = 10
@@ -62,61 +59,94 @@ class StatsResponse(BaseModel):
 class HealthResponse(BaseModel):
     status: str
     models_loaded: bool
+    message: Optional[str] = None
 
-# Global variables - lazy loading
 _bi_encoder = None
 _cross_encoder = None
 _groq_client = None
 _index = None
 _metadata = None
-_embeddings = None
 
 def get_bi_encoder():
-    """Lazy load bi-encoder"""
     global _bi_encoder
     if _bi_encoder is None:
-        logger.info("Loading bi-encoder...")
+        logger.info("Loading bi-encoder (MPNet)...")
         _bi_encoder = SentenceTransformer("all-mpnet-base-v2")
+        logger.info("✅ Bi-encoder loaded successfully")
     return _bi_encoder
 
 def get_cross_encoder():
-    """Lazy load cross-encoder"""
     global _cross_encoder
     if _cross_encoder is None:
         logger.info("Loading cross-encoder...")
         _cross_encoder = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")
+        logger.info("✅ Cross-encoder loaded successfully")
     return _cross_encoder
 
 def get_groq_client():
-    """Lazy load Groq client"""
     global _groq_client
     if _groq_client is None:
         logger.info("Initializing Groq client...")
         groq_api_key = os.getenv("GROQ_API_KEY", "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")
-        _groq_client = Groq(api_key=groq_api_key)
+        
+        try:
+            # Try standard initialization
+            _groq_client = Groq(api_key=groq_api_key)
+            logger.info("✅ Groq client initialized (standard)")
+        except TypeError as e:
+            logger.warning(f"Standard Groq init failed: {e}, trying with custom HTTP client...")
+            try:
+                # Fallback with custom HTTP client
+                http_client = httpx.Client(timeout=60.0)
+                _groq_client = Groq(
+                    api_key=groq_api_key,
+                    http_client=http_client
+                )
+                logger.info("✅ Groq client initialized (with custom HTTP client)")
+            except Exception as e2:
+                logger.error(f"❌ Failed to initialize Groq client: {e2}")
+                raise HTTPException(
+                    status_code=503,
+                    detail=f"Failed to initialize Groq client: {str(e2)}"
+                )
+    
     return _groq_client
 
 def get_index():
-    """Lazy load FAISS index"""
-    global _index, _embeddings
+    global _index
     if _index is None:
-        logger.info("Loading embeddings and creating index...")
-        _embeddings = np.load("final_legal_embeddings.npy")
-        _index = faiss.IndexFlatL2(_embeddings.shape[1])
-        _index.add(_embeddings.astype('float32'))
+        logger.info("Loading embeddings and creating FAISS index...")
+        try:
+            embeddings = np.load("final_legal_embeddings.npy")
+            logger.info(f"Embeddings shape: {embeddings.shape}")
+            _index = faiss.IndexFlatL2(embeddings.shape[1])
+            _index.add(embeddings.astype('float32'))
+            logger.info(f"✅ FAISS index created with {embeddings.shape[0]} vectors")
+        except FileNotFoundError:
+            logger.error("❌ Embeddings file not found")
+            raise HTTPException(
+                status_code=503,
+                detail="Embeddings file not found. Please upload final_legal_embeddings.npy"
+            )
     return _index
 
 def get_metadata():
-    """Lazy load metadata"""
     global _metadata
     if _metadata is None:
         logger.info("Loading metadata...")
-        with open("final_legal_laws_metadata.json", "r", encoding="utf-8") as f:
-            _metadata = json.load(f)
+        try:
+            with open("final_legal_laws_metadata.json", "r", encoding="utf-8") as f:
+                _metadata = json.load(f)
+            logger.info(f"✅ Loaded {len(_metadata)} legal provisions")
+        except FileNotFoundError:
+            logger.error("❌ Metadata file not found")
+            raise HTTPException(
+                status_code=503,
+                detail="Metadata file not found. Please upload final_legal_laws_metadata.json"
+            )
     return _metadata
 
 def get_premium_context(query: str, max_sources: int = 10) -> List[Dict]:
-    """Hybrid retrieval with cross-encoder reranking"""
     try:
         bi_encoder = get_bi_encoder()
         cross_encoder = get_cross_encoder()
@@ -159,38 +189,54 @@ def get_premium_context(query: str, max_sources: int = 10) -> List[Dict]:
             
             candidates = sorted(candidates, key=lambda x: x['rel_score'], reverse=True)[:max_sources]
         
+        logger.info(f"Retrieved {len(candidates)} relevant candidates")
         return candidates
         
     except Exception as e:
         logger.error(f"Error in context retrieval: {str(e)}")
-        return []
+        raise HTTPException(status_code=500, detail=f"Context retrieval error: {str(e)}")
 
 @app.get("/health", response_model=HealthResponse)
 async def health_check():
     """Health check endpoint"""
+    try:
+        metadata = get_metadata()
+        models_loaded = True
+        message = f"API is healthy. {len(metadata)} provisions loaded."
+    except Exception as e:
+        models_loaded = False
+        message = f"Error: {str(e)}"
+    
     return {
-        "status": "healthy",
-        "models_loaded": True
+        "status": "healthy" if models_loaded else "unhealthy",
+        "models_loaded": models_loaded,
+        "message": message
     }
 
 @app.get("/stats", response_model=StatsResponse)
 async def get_statistics():
     """Get database statistics"""
-    metadata = get_metadata()
-    unique_laws = len(set(d.get('law', '') for d in metadata))
-    
-    return {
-        "total_provisions": len(metadata),
-        "total_laws": unique_laws,
-        "vector_dimensions": 768,
-        "embedding_model": "all-mpnet-base-v2",
-        "reranking_model": "ms-marco-MiniLM-L-6-v2",
-        "llm_model": "llama-3.3-70b-versatile"
-    }
+    try:
+        metadata = get_metadata()
+        unique_laws = len(set(d.get('law', '') for d in metadata))
+        
+        return {
+            "total_provisions": len(metadata),
+            "total_laws": unique_laws,
+            "vector_dimensions": 768,
+            "embedding_model": "all-mpnet-base-v2",
+            "reranking_model": "ms-marco-MiniLM-L-6-v2",
+            "llm_model": "llama-3.3-70b-versatile"
+        }
+    except Exception as e:
+        logger.error(f"Error getting stats: {str(e)}")
+        raise HTTPException(status_code=503, detail=str(e))
 
 @app.post("/query", response_model=QueryResponse)
 async def process_legal_query(request: QueryRequest):
     """Process legal query with RAG pipeline"""
+    
+    # Validation
     if not request.query.strip():
         raise HTTPException(status_code=400, detail="Query cannot be empty")
     
@@ -205,13 +251,13 @@ async def process_legal_query(request: QueryRequest):
         
         if not candidates:
             return {
-                "answer": "No relevant legal provisions found in the database for your query.",
+                "answer": "No relevant legal provisions found in the database for your query. Please try rephrasing or consult a legal professional.",
                 "sources": [],
                 "query": request.query,
                 "total_candidates": 0
             }
         
-        # Build context
+        # Build context string
         context_str = "\n\n".join([
             f"[{d['law']} Section {d['section']}]: {d['text']}"
             for d in candidates
@@ -222,17 +268,19 @@ async def process_legal_query(request: QueryRequest):
 
 OPERATIONAL MANDATE:
 1. Answer STRICTLY from provided legal text
-2. If information is absent, state: "No specific provision found"
+2. If information is absent, state: "No specific provision found in current database"
 3. Always cite exact Law name and Section number
 4. Use formal, authoritative legal language
 5. NEVER hallucinate or infer beyond provided text
 6. Maintain zero-tolerance policy for speculation
 
-Format: "According to [Law], Section [Number]..."
-"""
+When citing, use format: "According to [Law Name], Section [Number]..."
+Provide clear, structured answers with proper legal citations."""
         
-        # Generate response
+        # Generate response using Groq
+        logger.info("Generating LLM response...")
         groq_client = get_groq_client()
+        
         response = groq_client.chat.completions.create(
             model="llama-3.3-70b-versatile",
             messages=[
@@ -257,6 +305,8 @@ Format: "According to [Law], Section [Number]..."
             for d in candidates
         ]
         
+        logger.info(f"✅ Query processed successfully with {len(sources)} sources")
+        
         return {
             "answer": answer,
             "sources": sources,
@@ -264,19 +314,27 @@ Format: "According to [Law], Section [Number]..."
             "total_candidates": len(candidates)
         }
         
+    except HTTPException:
+        raise
     except Exception as e:
-        logger.error(f"Error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
+        logger.error(f"Error processing query: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Query processing error: {str(e)}")
 
 @app.get("/")
 async def root():
-    """Root endpoint - redirect to docs"""
+    """Root endpoint - API info"""
     return {
-        "message": "LexNepal AI API",
+        "message": "🇳🇵 LexNepal AI API is running",
         "version": "1.0.0",
-        "docs": "/docs",
-        "health": "/health",
-        "stats": "/stats"
+        "description": "Advanced Legal Intelligence for Nepal Legal Code",
+        "endpoints": {
+            "docs": "/ (Swagger UI)",
+            "health": "/health (GET)",
+            "stats": "/stats (GET)",
+            "query": "/query (POST)"
+        },
+        "technology": "RAG with Hybrid Retrieval + Cross-Encoder Reranking",
+        "support": "https://huggingface.co/spaces/yamraj047/lexnepal-api"
     }
 
 if __name__ == "__main__":