Update app.py

app.py

@@ -19,13 +19,13 @@ class LegalAssistant:
     def __init__(self):
         try:
             # Initialize and verify ChromaDB content
-            logger.info("Initializing LegalAssistant...")
+            logger.info("Initializing Bharateeya Nyaya Sanhita Assistant...")
             
             # Try to verify content, if fails, try to initialize
             if not test_chromadb_content():
                 logger.warning("ChromaDB verification failed, attempting to initialize...")
                 if not initialize_chromadb():
-                    raise ValueError("Failed to initialize ChromaDB")
+                    raise ValueError("Failed to initialize ChromaDB with BNS content")
             
             # Initialize ChromaDB client
             base_path = os.path.dirname(os.path.abspath(__file__))
@@ -40,7 +40,7 @@ class LegalAssistant:
                 embedding_function=self.embedding_function
             )
             
-            logger.info(f"Collection loaded with {self.collection.count()} documents")
+            logger.info(f"BNS Collection loaded with {self.collection.count()} sections")
             
             # Initialize Mistral AI client
             self.mistral_client = OpenAI(
@@ -48,18 +48,18 @@ class LegalAssistant:
                 base_url="https://api.mistral.ai/v1"
             )
             
-            logger.info("LegalAssistant initialized successfully")
+            logger.info("BNS Assistant initialized successfully")
             
         except Exception as e:
-            logger.error(f"Error initializing LegalAssistant: {str(e)}")
+            logger.error(f"Error initializing BNS Assistant: {str(e)}")
             raise
 
     def validate_query(self, query: str) -> tuple[bool, str]:
         """Validate the input query"""
         if not query or len(query.strip()) < 10:
-            return False, "Query too short. Please provide more details (minimum 10 characters)."
+            return False, "Please provide a more detailed question about the Bharateeya Nyaya Sanhita (minimum 10 characters)."
         if len(query) > 500:
-            return False, "Query too long. Please be more concise (maximum 500 characters)."
+            return False, "Please make your question more concise (maximum 500 characters)."
         return True, ""
 
     def get_response(self, query: str) -> dict:
@@ -70,8 +70,8 @@ class LegalAssistant:
             if not is_valid:
                 return {
                     "answer": error_message,
-                    "references": [],
-                    "summary": "Invalid query",
+                    "references": ["No specific references from Bharateeya Nyaya Sanhita"],
+                    "summary": "Query validation failed",
                     "confidence": "LOW"
                 }
 
@@ -83,9 +83,9 @@ class LegalAssistant:
             
             if not results['documents'][0]:
                 return {
-                    "answer": "No relevant information found in the document.",
-                    "references": [],
-                    "summary": "No matching content",
+                    "answer": "No relevant information found in the Bharateeya Nyaya Sanhita.",
+                    "references": ["No specific references from Bharateeya Nyaya Sanhita"],
+                    "summary": "No matching content in BNS",
                     "confidence": "LOW"
                 }
             
@@ -100,43 +100,52 @@ class LegalAssistant:
             context = "\n\n".join(context_parts)
             
             # Prepare system prompt with explicit JSON format
-            system_prompt = '''You are a specialized legal assistant that MUST follow these STRICT rules:
+            system_prompt = '''You are a specialized legal assistant for the Bharateeya Nyaya Sanhita (BNS) that MUST follow these STRICT rules:
 
 1. You MUST ONLY use information from the provided context.
 2. DO NOT use any external knowledge about laws, IPC, Constitution, or legal matters.
 3. Your response MUST be in this EXACT JSON format:
 {
-    "answer": "Your detailed answer using ONLY information from the context",
-    "reference_sections": ["List of section titles used from context"],
-    "summary": "Brief 2-3 line summary",
+    "answer": "Your detailed answer explaining BNS sections in simple, easy-to-understand language. Start with 'The Bharateeya Nyaya Sanhita...'",
+    "reference_sections": ["List of relevant BNS section titles"],
+    "summary": "Provide a user-friendly summary that explains:\n1. What BNS sections were found\n2. What each section covers\n3. How these sections relate to the query\nStart with 'In the Bharateeya Nyaya Sanhita...'",
     "confidence": "HIGH/MEDIUM/LOW"
 }
 
 Confidence Level Rules:
-- HIGH: When exact information is found in context
-- MEDIUM: When partial or indirect information is found
-- LOW: When information is unclear or not found
+- HIGH: When exact matching BNS sections and their details are found
+- MEDIUM: When partially relevant BNS sections are found
+- LOW: When sections are not clearly relevant or not found
+
+Response Guidelines:
+1. Always mention "Bharateeya Nyaya Sanhita" when referencing sections
+2. Explain legal terms in simple language
+3. Make the summary easy to understand for non-legal persons
+4. Break down complex legal concepts into simple explanations
+5. Use everyday examples where appropriate
 
 If information is not in context, respond with:
 {
-    "answer": "This information is not present in the provided document.",
+    "answer": "The Bharateeya Nyaya Sanhita sections related to your query are not present in the provided document.",
     "reference_sections": [],
-    "summary": "Information not found in document",
+    "summary": "No relevant sections found in the Bharateeya Nyaya Sanhita document",
     "confidence": "LOW"
 }'''
 
             # Prepare user content
-            content = f'''Context Sections:
+            content = f'''Context Sections from Bharateeya Nyaya Sanhita:
 {context}
 
 Question: {query}
 
 IMPORTANT:
-1. Use ONLY the information from the above context
-2. Format your response as a valid JSON object with the exact structure shown above
-3. Include ONLY section titles that exist in the context
-4. DO NOT add any text outside the JSON structure
-5. Ensure the JSON is properly formatted with double quotes'''
+1. Use ONLY the information from the above BNS context
+2. Format your response as a valid JSON object
+3. Always reference "Bharateeya Nyaya Sanhita" in your response
+4. Explain each section in simple, user-friendly language
+5. Make the summary comprehensive but easy to understand
+6. Break down legal concepts for non-legal persons
+7. Ensure proper JSON formatting with double quotes'''
 
             # Get response from Mistral AI
             response = self.mistral_client.chat.completions.create(
@@ -145,8 +154,8 @@ IMPORTANT:
                     {"role": "system", "content": system_prompt},
                     {"role": "user", "content": content}
                 ],
-                temperature=0.1,
-                max_tokens=1000,
+                temperature=0.3,
+                max_tokens=1500,
                 response_format={ "type": "json_object" }
             )
             
@@ -168,43 +177,52 @@ IMPORTANT:
                     valid_references = [ref for ref in result["reference_sections"]
                                      if ref in references]
                     
+                    # Format references to include BNS
+                    formatted_references = [f"Bharateeya Nyaya Sanhita - {ref}" 
+                                         for ref in valid_references]
+                    
                     # If references don't match, adjust confidence
                     if len(valid_references) != len(result["reference_sections"]):
-                        result["reference_sections"] = valid_references
+                        formatted_references = ["No specific references from Bharateeya Nyaya Sanhita"]
                         result["confidence"] = "LOW"
                     
-                    # Ensure answer and summary are strings
-                    result["answer"] = str(result["answer"])
-                    result["summary"] = str(result["summary"])
+                    # Ensure answer and summary are properly formatted
+                    answer = str(result["answer"])
+                    if not answer.startswith("The Bharateeya Nyaya Sanhita"):
+                        answer = f"The Bharateeya Nyaya Sanhita states that {answer.lower()}"
+                    
+                    summary = str(result["summary"])
+                    if not summary.startswith("In the Bharateeya Nyaya Sanhita"):
+                        summary = f"In the Bharateeya Nyaya Sanhita, {summary.lower()}"
                     
                     return {
-                        "answer": result["answer"],
-                        "references": valid_references,
-                        "summary": result["summary"],
+                        "answer": answer,
+                        "references": formatted_references,
+                        "summary": summary,
                         "confidence": result["confidence"]
                     }
                     
                 except json.JSONDecodeError as e:
                     logger.error(f"JSON parsing error: {str(e)}")
                     return {
-                        "answer": "Error: Failed to parse response format",
-                        "references": [],
-                        "summary": "Response format error",
+                        "answer": "Error: Unable to process the response format",
+                        "references": ["No specific references from Bharateeya Nyaya Sanhita"],
+                        "summary": "Could not generate summary due to processing error",
                         "confidence": "LOW"
                     }
                 except ValueError as e:
                     logger.error(f"Validation error: {str(e)}")
                     return {
-                        "answer": "Error: Invalid response structure",
-                        "references": [],
-                        "summary": "Response validation error",
+                        "answer": "Error: Response structure was invalid",
+                        "references": ["No specific references from Bharateeya Nyaya Sanhita"],
+                        "summary": "Could not generate summary due to validation error",
                         "confidence": "LOW"
                     }
             
             return {
-                "answer": "Error: No valid response received",
-                "references": [],
-                "summary": "No response generated",
+                "answer": "Error: No valid response received from the system",
+                "references": ["No specific references from Bharateeya Nyaya Sanhita"],
+                "summary": "Could not generate summary due to system error",
                 "confidence": "LOW"
             }
             
@@ -212,8 +230,8 @@ IMPORTANT:
             logger.error(f"Error in get_response: {str(e)}")
             return {
                 "answer": f"Error: {str(e)}",
-                "references": [],
-                "summary": "System error occurred",
+                "references": ["No specific references from Bharateeya Nyaya Sanhita"],
+                "summary": "Could not generate summary due to system error",
                 "confidence": "LOW"
             }
 
@@ -221,7 +239,7 @@ IMPORTANT:
 try:
     assistant = LegalAssistant()
 except Exception as e:
-    logger.error(f"Failed to initialize LegalAssistant: {str(e)}")
+    logger.error(f"Failed to initialize BNS Assistant: {str(e)}")
     raise
 
 def process_query(query: str) -> tuple:
@@ -229,49 +247,65 @@ def process_query(query: str) -> tuple:
     response = assistant.get_response(query)
     return (
         response["answer"],
-        ", ".join(response["references"]) if response["references"] else "No specific references",
-        response["summary"] if response["summary"] else "No summary available",
+        ", ".join(response["references"]),
+        response["summary"],
         response["confidence"]
     )
 
 # Create the Gradio interface
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("""
-    # Indian Legal Assistant
+    # Bharateeya Nyaya Sanhita Assistant
+    ## Your Guide to Understanding the BNS
+
+    This assistant helps you understand sections and provisions of the Bharateeya Nyaya Sanhita (BNS) in simple, clear language.
+    
     ## Guidelines for Queries:
-    1. Be specific and clear in your questions
-    2. End questions with a question mark or period
+    1. Ask specific questions about BNS sections or topics
+    2. End questions with a question mark
     3. Keep queries between 10-500 characters
-    4. Questions will be answered based ONLY on the provided legal document
+    4. Example queries:
+       - "What does the BNS say about theft?"
+       - "Explain the provisions related to property offenses in BNS."
+       - "What are the sections dealing with criminal breach of trust?"
     """)
     
     with gr.Row():
         query_input = gr.Textbox(
-            label="Enter your legal query",
-            placeholder="e.g., What are the main provisions in this document?"
+            label="Enter your query about Bharateeya Nyaya Sanhita",
+            placeholder="e.g., What are the main provisions about theft in BNS?"
         )
     
     with gr.Row():
-        submit_btn = gr.Button("Submit", variant="primary")
+        submit_btn = gr.Button("Get BNS Information", variant="primary")
     
     with gr.Row():
-        confidence_output = gr.Textbox(label="Confidence Level")
+        confidence_output = gr.Textbox(label="Information Reliability Level")
     
     with gr.Row():
-        answer_output = gr.Textbox(label="Answer", lines=5)
+        answer_output = gr.Textbox(
+            label="Detailed Explanation", 
+            lines=5
+        )
     
     with gr.Row():
         with gr.Column():
-            references_output = gr.Textbox(label="Document References", lines=2)
+            references_output = gr.Textbox(
+                label="BNS Section References",
+                lines=2
+            )
         with gr.Column():
-            summary_output = gr.Textbox(label="Summary", lines=2)
+            summary_output = gr.Textbox(
+                label="Simple Summary",
+                lines=2
+            )
     
     gr.Markdown("""
     ### Important Notes:
-    - Responses are based ONLY on the provided document
-    - No external legal knowledge is used
-    - All references are from the document itself
-    - Confidence levels indicate how well the answer matches the document content
+    - All information is sourced directly from the Bharateeya Nyaya Sanhita
+    - Responses are based only on the official BNS document
+    - The assistant explains legal concepts in simple, understandable language
+    - Reliability level indicates how well your query matches BNS content
     """)
     
     submit_btn.click(