much enhanced UI

.gitattributes

@@ -33,5 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-data/tenant-landlord.pdf filter=lfs diff=lfs merge=lfs -text
 tenant-landlord.pdf filter=lfs diff=lfs merge=lfs -text

app.py

@@ -1,43 +1,63 @@
 import os
-import json
 import logging
 from typing import Dict, List, Optional
 from functools import lru_cache
 import re
 
 import gradio as gr
-from langchain_openai import ChatOpenAI
+try:
+    from vector_db import VectorDatabase
+except ImportError:
+    print("Error: Could not import VectorDatabase from vector_db.py.")
+    print("Please ensure vector_db.py exists in the same directory and is correctly defined.")
+    exit(1)
+
+try:
+    from langchain_openai import ChatOpenAI
+except ImportError:
+    print("Error: langchain-openai not found. Please install it: pip install langchain-openai")
+    exit(1)
+
 from langchain.prompts import PromptTemplate
 from langchain.chains import LLMChain
-# Make sure vector_db.py is in the same directory or accessible via PYTHONPATH
-from vector_db import VectorDatabase # <-- This now imports the placeholder
 
-# Enhanced logging for better debugging
+# Suppress warnings
+import warnings
+warnings.filterwarnings("ignore", category=SyntaxWarning)
+warnings.filterwarnings("ignore", category=UserWarning, message=".*You are using gradio version.*")
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+# Enhanced logging
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - [%(filename)s:%(lineno)d] - %(message)s'
 )
 
+# --- RAGSystem Class ---
 class RAGSystem:
+    # (Keep the RAGSystem class exactly the same as in the previous version)
+    # ... __init__ ...
+    # ... extract_statutes ...
+    # ... process_query_cached ...
+    # ... process_query ...
+    # ... get_states ...
+    # ... load_pdf ...
     def __init__(self, vector_db: Optional[VectorDatabase] = None):
         logging.info("Initializing RAGSystem")
-        # If no vector_db instance is passed, create one (uses placeholder for now)
         self.vector_db = vector_db if vector_db else VectorDatabase()
         self.llm = None
         self.chain = None
-
-        # Using f-string for potentially better readability/maintenance if template gets complex
         self.prompt_template_str = """You are a legal assistant specializing in tenant rights and landlord-tenant laws. Your goal is to provide accurate, detailed, and helpful answers grounded in legal authority. Use the provided statutes as the primary source when available. If no relevant statutes are found in the context, rely on your general knowledge to provide a pertinent and practical response, clearly indicating when you are doing so and prioritizing state-specific information over federal laws for state-specific queries.
 
 Instructions:
-*   Use the context and statutes as the primary basis for your answer when available.
-*   For state-specific queries, prioritize statutes or legal principles from the specified state over federal laws.
-*   Cite relevant statutes (e.g., (AS § 34.03.220(a)(2))) explicitly in your answer when applicable.
-*   If multiple statutes apply, list all relevant ones.
-*   If no specific statute is found in the context, state this clearly (e.g., 'No specific statute was found in the provided context'), then provide a general answer based on common legal principles or practices, marked as such.
-*   Include practical examples or scenarios to enhance clarity and usefulness.
-*   Use bullet points or numbered lists for readability when appropriate.
-*   Maintain a professional and neutral tone.
+* Use the context and statutes as the primary basis for your answer when available.
+* For state-specific queries, prioritize statutes or legal principles from the specified state over federal laws.
+* Cite relevant statutes (e.g., (AS § 34.03.220(a)(2))) explicitly in your answer when applicable.
+* If multiple statutes apply, list all relevant ones.
+* If no specific statute is found in the context, state this clearly (e.g., 'No specific statute was found in the provided context'), then provide a general answer based on common legal principles or practices, marked as such.
+* Include practical examples or scenarios to enhance clarity and usefulness.
+* Use bullet points or numbered lists for readability when appropriate.
+* Maintain a professional and neutral tone.
 
 Question: {query}
 State: {state}
@@ -56,491 +76,716 @@ Answer:"""
         )
         logging.info("RAGSystem initialized.")
 
-    def initialize_llm(self, openai_api_key: str):
-        """Initializes the LLM and the processing chain."""
-        if not openai_api_key:
-            logging.error("Attempted to initialize LLM without API key.")
-            raise ValueError("OpenAI API key is required.")
-
-        # Avoid re-initializing if already done with the same key implicitly
-        # Note: This simple check doesn't handle key changes well.
-        # A more robust approach might involve checking if self.llm's key matches.
-        if self.llm and self.chain:
-            # Check if the key is the same (conceptually - can't directly read from ChatOpenAI instance easily)
-            # If key changes are expected, need a more complex re-initialization logic.
-             logging.info("LLM and Chain already initialized.")
-             return
-
-        try:
-            logging.info("Initializing OpenAI LLM...")
-            self.llm = ChatOpenAI(
-                temperature=0.2,
-                openai_api_key=openai_api_key,
-                model_name="gpt-3.5-turbo",
-                max_tokens=1500, # Max response tokens
-                request_timeout=45 # Increased timeout
-            )
-            logging.info("OpenAI LLM initialized successfully.")
-
-            self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-            logging.info("LLMChain created successfully.")
-        except Exception as e:
-            logging.error(f"Failed to initialize OpenAI LLM or Chain: {str(e)}")
-            # Reset llm/chain if initialization failed partially
-            self.llm = None
-            self.chain = None
-            raise  # Re-raise the exception to be caught by the caller
-
     def extract_statutes(self, text: str) -> str:
-        """
-        Extract statute citations from the given text using a refined regex pattern.
-        Returns a string of valid statutes, one per line, or a message if none are found.
-        """
-        # Refined Regex: Aims to capture common US statute formats. May need tuning.
-        # - Allows state abbreviations (e.g., CA, NY) or full names (e.g, California)
-        # - Looks for common terms like Code, Laws, Statutes, CCP, USC, ILCS
-        # - Requires section symbol (§) followed by numbers/hyphens/parenthesized parts
-        # - Tries to avoid matching simple parenthetical remarks like '(a)' or '(found here)'
-        statute_pattern = r'\b(?:[A-Z]{2,}\.?\s+(?:Rev\.\s+)?Stat\.?|Code(?:\s+Ann\.?)?|Ann\.?\s+Laws|Statutes|CCP|USC|ILCS|Civ\.\s+Code|Penal\s+Code|Gen\.\s+Oblig\.\s+Law)\s+§\s*[\d\-]+(?:\.\d+)?(?:\([\w\.]+\))?|Title\s+\d+\s+USC\s+§\s*\d+(?:-\d+)?\b'
-
-        # Use finditer for more control if needed later, findall is simpler for now
+        statute_pattern = r'\b(?:[A-Z]{2,}\.?\s+(?:Rev\.\s+)?Stat\.?|Code(?:\s+Ann\.?)?|Ann\.?\s+Laws|Statutes|CCP|USC|ILCS|Civ\.\s+Code|Penal\s+Code|Gen\.\s+Oblig\.\s+Law|R\.?S\.?|P\.?L\.?)\s+§\s*[\d\-]+(?:\.\d+)?(?:[\(\w\.\)]+)?|Title\s+\d+\s+USC\s+§\s*\d+(?:-\d+)?\b'
         statutes = re.findall(statute_pattern, text, re.IGNORECASE)
-
         valid_statutes = []
-        # Basic filtering (can be improved)
         for statute in statutes:
-             # Remove potential leading/trailing spaces and ensure it looks like a statute
-             statute = statute.strip()
-             if '§' in statute and any(char.isdigit() for char in statute):
-                 # Avoid things that might just be section references like '(a)' or URLs mistakenly caught
+            statute = statute.strip()
+            if '§' in statute and any(char.isdigit() for char in statute):
                  if not re.match(r'^\([\w\.]+\)$', statute) and 'http' not in statute:
-                     valid_statutes.append(statute)
+                    if len(statute) > 5:
+                        valid_statutes.append(statute)
 
         if valid_statutes:
-            # Deduplicate while preserving order
             seen = set()
-            unique_statutes = [s for s in valid_statutes if not (s in seen or seen.add(s))]
+            unique_statutes = [s for s in valid_statutes if not (s.rstrip('.,;') in seen or seen.add(s.rstrip('.,;')))]
             logging.info(f"Extracted {len(unique_statutes)} unique statutes.")
-            return "\n".join(f"- {s}" for s in unique_statutes) # Format as list
+            return "\n".join(f"- {s}" for s in unique_statutes)
 
         logging.info("No statutes found matching the pattern in the context.")
         return "No specific statutes found in the provided context."
 
-    # Cache results for the same query, state, and key (key isn't explicitly cached but influences init)
-    @lru_cache(maxsize=100)
-    def process_query(self, query: str, state: str, openai_api_key: str, n_results: int = 5) -> Dict[str, any]:
-        """Processes the user query using RAG."""
-        logging.info(f"Processing query: '{query}' for state: '{state}' with n_results={n_results}")
-
-        # 1. Input Validation
-        if not state:
-            logging.warning("No state provided for query.")
-            return {
-                "answer": "**Error:** Please select a state to proceed with your query.",
-                "context_used": "N/A"
-            }
-        if not query:
+    @lru_cache(maxsize=50)
+    def process_query_cached(self, query: str, state: str, openai_api_key: str, n_results: int = 5) -> Dict[str, any]:
+        logging.info(f"Processing query (cache key: '{query}'|'{state}'|key_hidden) with n_results={n_results}")
+
+        if not state or state == "Select a state..." or "Error" in state:
+            logging.warning("No valid state provided for query.")
+            return {"answer": "<div class='error-message'>Error: Please select a valid state.</div>", "context_used": "N/A - Invalid Input"}
+        if not query or not query.strip():
             logging.warning("No query provided.")
-            return {
-                "answer": "**Error:** Please enter your question in the Query box.",
-                "context_used": "N/A"
-            }
-        if not openai_api_key:
-            logging.warning("No OpenAI API key provided.")
-            return {
-                "answer": "**Error:** Please provide an OpenAI API key to proceed.",
-                "context_used": "N/A"
-            }
-
-        # 2. Initialize LLM (if needed)
+            return {"answer": "<div class='error-message'>Error: Please enter your question.</div>", "context_used": "N/A - Invalid Input"}
+        if not openai_api_key or not openai_api_key.strip() or not openai_api_key.startswith("sk-"):
+            logging.warning("No valid OpenAI API key provided.")
+            return {"answer": "<div class='error-message'>Error: Please provide a valid OpenAI API key (starting with 'sk-'). Get one from <a href='https://platform.openai.com/api-keys' target='_blank'>OpenAI</a>.</div>", "context_used": "N/A - Invalid Input"}
+
         try:
-            # Initialize LLM here, ensuring it's ready before DB query or LLM call
-            self.initialize_llm(openai_api_key)
+            logging.info("Initializing temporary LLM and Chain for this query...")
+            temp_llm = ChatOpenAI(
+                temperature=0.2, openai_api_key=openai_api_key, model_name="gpt-3.5-turbo",
+                max_tokens=1500, request_timeout=45
+            )
+            temp_chain = LLMChain(llm=temp_llm, prompt=self.prompt_template)
+            logging.info("Temporary LLM and Chain initialized successfully.")
         except Exception as e:
-            logging.error(f"LLM Initialization failed: {str(e)}")
-            return {
-                "answer": f"**Error:** Failed to initialize the AI model. Please check your API key and network connection. ({str(e)})",
-                "context_used": "N/A"
-            }
-
-        # Ensure chain is initialized after initialize_llm() call succeeds
-        if not self.chain:
-             logging.error("LLM Chain is not initialized after attempting LLM initialization.")
-             return {
-                  "answer": "**Error:** Internal system error. Failed to prepare the processing chain.",
-                  "context_used": "N/A"
-             }
-
-
-        # 3. Query Vector Database
-        context = "No relevant context found." # Default context
+            logging.error(f"LLM Initialization failed: {str(e)}", exc_info=True)
+            error_msg = "Error: Failed to initialize AI model. Please check your network connection and API key validity."
+            if "authentication" in str(e).lower():
+                error_msg = "Error: OpenAI API Key is invalid or expired. Please check your key."
+            return {"answer": f"<div class='error-message'>{error_msg}</div><div class='error-details'>Details: {str(e)}</div>", "context_used": "N/A - LLM Init Failed"}
+
+        context = "No relevant context found."
+        statutes_from_context = "Statute retrieval skipped due to context issues."
         try:
+            logging.info(f"Querying Vector DB for query: '{query[:50]}...' in state '{state}'...")
             results = self.vector_db.query(query, state=state, n_results=n_results)
-            logging.info(f"Vector database query successful for state '{state}'.")
-            # logging.debug(f"Raw query results: {json.dumps(results, indent=2)}")
+            logging.info(f"Vector DB query successful for state '{state}'. Processing results...")
 
             context_parts = []
-            # Process document results carefully, checking list structure
             doc_results = results.get("document_results", {})
-            docs = doc_results.get("documents", [[]])[0] # Safely access first list
-            metadatas = doc_results.get("metadatas", [[]])[0] # Safely access first list
-
+            docs = doc_results.get("documents", [[]])[0]
+            metadatas = doc_results.get("metadatas", [[]])[0]
             if docs and metadatas and len(docs) == len(metadatas):
+                logging.info(f"Found {len(docs)} document chunks.")
                 for i, doc_content in enumerate(docs):
                     metadata = metadatas[i]
                     state_label = metadata.get('state', 'Unknown State')
                     chunk_id = metadata.get('chunk_id', 'N/A')
-                    context_parts.append(f"[{state_label} - Chunk {chunk_id}] {doc_content}")
-            else:
-                logging.warning("No document results or mismatch in docs/metadata lengths.")
+                    context_parts.append(f"**Source: Document Chunk {chunk_id} (State: {state_label})**\n{doc_content}")
 
-            # Process state summary results
             state_results_data = results.get("state_results", {})
             state_docs = state_results_data.get("documents", [[]])[0]
             state_metadatas = state_results_data.get("metadatas", [[]])[0]
-
             if state_docs and state_metadatas and len(state_docs) == len(state_metadatas):
-                 for i, state_doc_content in enumerate(state_docs):
+                logging.info(f"Found {len(state_docs)} state summary documents.")
+                for i, state_doc_content in enumerate(state_docs):
                     metadata = state_metadatas[i]
-                    state_label = metadata.get('state', state) # Use provided state if not in metadata
-                    context_parts.append(f"[{state_label} - Summary] {state_doc_content}")
-            else:
-                 logging.warning("No state summary results found.")
+                    state_label = metadata.get('state', state)
+                    context_parts.append(f"**Source: State Summary (State: {state_label})**\n{state_doc_content}")
 
             if context_parts:
                 context = "\n\n---\n\n".join(context_parts)
-                logging.info(f"Constructed context with {len(context_parts)} parts.")
-                # Limit context length if necessary (though max_tokens helps)
-                # max_context_len = 5000 # Example limit
-                # if len(context) > max_context_len:
-                #     context = context[:max_context_len] + "\n... [Context Truncated]"
-                #     logging.warning("Context truncated due to length.")
+                logging.info(f"Constructed context with {len(context_parts)} parts. Length: {len(context)} chars.")
+                try:
+                    statutes_from_context = self.extract_statutes(context)
+                except Exception as e:
+                    logging.error(f"Error extracting statutes: {e}", exc_info=True)
+                    statutes_from_context = "Error extracting statutes from context."
             else:
-                logging.warning("No relevant context parts found after processing DB results.")
-                context = "No relevant context could be retrieved from the available documents for your query and selected state."
-
+                logging.warning("No relevant context parts found from vector DB query.")
+                context = "No relevant context could be retrieved from the knowledge base for this query and state. The AI will answer from its general knowledge."
+                statutes_from_context = "No specific statutes found as no context was retrieved."
 
         except Exception as e:
-            logging.error(f"Vector database query or context processing failed: {str(e)}", exc_info=True)
-            # Fallback to general knowledge if DB fails, but inform the user
-            context = f"An error occurred while retrieving specific legal documents ({str(e)}). I will attempt to answer based on general knowledge, but it may lack state-specific details."
-            statutes_from_context = "Statute retrieval skipped due to context error."
-
-
-        # 4. Extract Statutes from Retrieved Context (if context retrieval succeeded)
-        statutes_from_context = "No specific statutes found in the provided context."
-        if "An error occurred while retrieving" not in context and "No relevant context found" not in context:
-             try:
-                statutes_from_context = self.extract_statutes(context)
-                logging.info(f"Statutes extracted: {statutes_from_context}")
-             except Exception as e:
-                 logging.error(f"Error extracting statutes: {e}")
-                 statutes_from_context = "Error occurred during statute extraction."
-
+            logging.error(f"Vector DB query/context processing failed: {str(e)}", exc_info=True)
+            context = f"Warning: Error retrieving documents from the knowledge base ({str(e)}). The AI will attempt to answer from its general knowledge, which may be less specific or accurate."
+            statutes_from_context = "Statute retrieval skipped due to error retrieving context."
 
-        # 5. Generate Answer using LLM
         try:
-            logging.info("Invoking LLMChain...")
-            llm_input = {
-                "query": query,
-                "context": context,
-                "state": state,
-                "statutes": statutes_from_context
-            }
-            # logging.debug(f"Input to LLMChain: {json.dumps(llm_input, indent=2)}") # Be careful logging sensitive data
-            answer_dict = self.chain.invoke(llm_input)
+            logging.info("Invoking LLMChain with constructed input...")
+            llm_input = {"query": query, "context": context, "state": state, "statutes": statutes_from_context}
+            answer_dict = temp_chain.invoke(llm_input)
             answer_text = answer_dict.get('text', '').strip()
 
             if not answer_text:
-                 logging.warning("LLM returned an empty answer.")
-                 answer_text = "I received an empty response from the AI model. This might be a temporary issue. Please try rephrasing your question or try again later."
+                logging.warning("LLM returned an empty answer.")
+                answer_text = "<div class='error-message'>The AI model returned an empty response. This might be due to the query, context limitations, or temporary issues. Please try rephrasing your question or try again later.</div>"
+            else:
+                logging.info("LLM generated answer successfully.")
 
-            logging.info("LLM generated answer successfully.")
-            # logging.debug(f"Raw answer text from LLM: {answer_text}")
+            return {"answer": answer_text, "context_used": context}
 
-            return {
-                "answer": answer_text,
-                "context_used": context # Return the context for potential display or debugging
-            }
         except Exception as e:
             logging.error(f"LLM processing failed: {str(e)}", exc_info=True)
-            # Provide a more informative error message
-            error_message = f"**Error:** An error occurred while generating the answer. This could be due to issues with the AI model connection, API key limits, or the complexity of the request. Please try again later.\n\nDetails: {str(e)}"
-            # Check for common API errors
+            error_message = "Error: AI answer generation failed."
+            details = f"Details: {str(e)}"
             if "authentication" in str(e).lower():
-                 error_message = "**Error:** Authentication failed. Please check if your OpenAI API key is correct and active."
+                error_message = "Error: Authentication failed. Please double-check your OpenAI API key."
+                details = ""
             elif "rate limit" in str(e).lower():
-                 error_message = "**Error:** You've exceeded your OpenAI API usage limit. Please check your plan or try again later."
+                error_message = "Error: You've exceeded your OpenAI API rate limit or quota. Please check your usage and plan limits, or wait and try again."
+                details = ""
+            elif "context length" in str(e).lower():
+                error_message = "Error: The request was too long for the AI model. This can happen with very complex questions or extensive retrieved context."
+                details = "Try simplifying your question or asking about a more specific aspect."
+            elif "timeout" in str(e).lower():
+                 error_message = "Error: The request to the AI model timed out. The service might be busy."
+                 details = "Please try again in a few moments."
+
+            formatted_error = f"<div class='error-message'>{error_message}</div>"
+            if details:
+                formatted_error += f"<div class='error-details'>{details}</div>"
+
+            return {"answer": formatted_error, "context_used": context}
 
-            return {
-                "answer": error_message,
-                "context_used": context # Still return context for debugging
-            }
+    def process_query(self, query: str, state: str, openai_api_key: str, n_results: int = 5) -> Dict[str, any]:
+        return self.process_query_cached(query.strip(), state, openai_api_key.strip(), n_results)
 
     def get_states(self) -> List[str]:
-        """Retrieves the list of available states from the VectorDatabase."""
         try:
             states = self.vector_db.get_states()
             if not states:
-                 logging.warning("No states returned from vector_db.get_states(). Using default list.")
-                 # Provide a fallback list if needed
-                 return ["California", "New York", "Texas", "Florida", "Oregon", "Alabama", "Select State..."]
-            logging.info(f"Retrieved {len(states)} states from VectorDatabase.")
-            return sorted(list(set(states))) # Ensure uniqueness and sort
+                logging.warning("No states retrieved from vector_db. Returning empty list.")
+                return []
+            valid_states = sorted(list(set(s for s in states if s and isinstance(s, str) and s != "Select a state...")))
+            logging.info(f"Retrieved {len(valid_states)} unique, valid states from VectorDatabase.")
+            return valid_states
         except Exception as e:
-            logging.error(f"Failed to get states from VectorDatabase: {str(e)}")
-            return ["Error fetching states"] # Indicate error in the dropdown
+            logging.error(f"Failed to get states from VectorDatabase: {str(e)}", exc_info=True)
+            return ["Error: Could not load states"]
 
     def load_pdf(self, pdf_path: str) -> int:
-        """Loads and processes the PDF using the VectorDatabase."""
         if not os.path.exists(pdf_path):
-             logging.error(f"PDF file not found at path: {pdf_path}")
-             raise FileNotFoundError(f"PDF file not found: {pdf_path}")
+            logging.error(f"PDF file not found at path: {pdf_path}")
+            raise FileNotFoundError(f"PDF file not found: {pdf_path}")
         try:
-            logging.info(f"Attempting to load PDF: {pdf_path}")
-            num_states = self.vector_db.process_and_load_pdf(pdf_path)
-            if num_states > 0:
-                logging.info(f"Successfully processed PDF. Found data for {num_states} states.")
+            logging.info(f"Attempting to load/verify data from PDF: {pdf_path}")
+            num_states_processed = self.vector_db.process_and_load_pdf(pdf_path)
+            doc_count = self.vector_db.document_collection.count()
+            state_count = self.vector_db.state_collection.count()
+            total_items = doc_count + state_count
+
+            if total_items > 0:
+                logging.info(f"Vector DB contains {total_items} items ({doc_count} docs, {state_count} states). PDF processed or data already existed.")
+                current_states = self.get_states()
+                return len(current_states) if current_states and "Error" not in current_states[0] else 0
             else:
-                logging.warning(f"Processed PDF, but found no state-specific data according to vector_db implementation.")
-            return num_states
+                logging.warning(f"PDF processing completed, but the vector database appears empty. Check PDF content and processing logs.")
+                return 0
+
         except Exception as e:
             logging.error(f"Failed to load or process PDF '{pdf_path}': {str(e)}", exc_info=True)
-            # Depending on vector_db, this might leave the DB in a partial state.
-            return 0 # Indicate failure
+            raise RuntimeError(f"Failed to process PDF '{pdf_path}': {e}") from e
 
 
+    # --- GRADIO INTERFACE ---
     def gradio_interface(self):
-        """Creates and returns the Gradio interface."""
-
-        # Define the core function that Gradio will call
-        def query_interface(api_key: str, query: str, state: str) -> str:
-            # Clear cache for each new request if desired, or rely on LRU cache parameters
-            # self.process_query.cache_clear()
-            logging.info(f"Gradio interface received query: '{query}', state: '{state}'")
+        # Wrapper function for the Gradio interface logic
+        def query_interface_wrapper(api_key: str, query: str, state: str) -> str:
+            logging.info(f"Gradio interface received query: '{query[:50]}...', state: '{state}'")
+
+            # Re-validate inputs robustly
+            if not api_key or not api_key.strip() or not api_key.startswith("sk-"):
+                 return "<div class='error-message'>Please provide a valid OpenAI API key (starting with 'sk-'). <a href='https://platform.openai.com/api-keys' target='_blank'>Get one here</a>.</div>"
+            if not state or state == "Select a state..." or "Error" in state:
+                return "<div class='error-message'>Please select a valid state from the dropdown.</div>"
+            if not query or not query.strip():
+                return "<div class='error-message'>Please enter your question in the text box.</div>"
+
+            # Call the core processing logic
             result = self.process_query(query=query, state=state, openai_api_key=api_key)
 
-            # Format the response clearly using Markdown
-            answer = result.get("answer", "**Error:** No answer generated.")
-            # context_used = result.get("context_used", "N/A") # Optional: show context
+            # Format the response for display
+            answer = result.get("answer", "<div class='error-message'>An unexpected error occurred, and no answer was generated. Please check the logs or try again.</div>")
 
-            # Simple formatting for now, can be enhanced
-            formatted_response = f"### Answer for {state}:\n\n{answer}"
+            # Add a header *only* if the answer is not an error message itself
+            if not "<div class='error-message'>" in answer:
+                 formatted_response = f"<h3 class='response-header'>Response for {state}</h3><hr class='divider'>{answer}"
+            else:
+                 formatted_response = answer # Pass through error messages directly
 
-            # Optional: Include context for debugging/transparency (can be long)
-            # formatted_response += f"\n\n---\n<details><summary>Context Used (Debug)</summary>\n\n```\n{context_used}\n```\n</details>"
+            # Log context length for debugging (optional)
+            context_used = result.get("context_used", "N/A")
+            if isinstance(context_used, str) and "N/A" not in context_used:
+                logging.debug(f"Context length used for query: {len(context_used)} characters.")
+            else:
+                logging.debug(f"No context was used or available for this query ({context_used}).")
 
             return formatted_response
 
-        # Get states for the dropdown
-        available_states = self.get_states()
-        if not available_states or "Error" in available_states[0]:
-             logging.error("Could not load states for dropdown. Interface might be unusable.")
-             # Handle case where states couldn't be loaded
-             available_states = ["Error: Could not load states"]
-
-
-        # Define example queries (only query and state needed for examples UI)
-        example_queries = [
-            ["What is the rent due date law?", "California"],
-            ["What are the rules for security deposit returns?", "New York"],
-            ["Can a landlord enter without notice?", "Texas"],
-            ["What are the eviction notice requirements?", "Florida"],
-            ["Are there rent control laws?", "Oregon"]
+        # --- Get Available States for Dropdown ---
+        try:
+            available_states_list = self.get_states()
+            if not available_states_list or "Error" in available_states_list[0]:
+                dropdown_choices = ["Error: Could not load states"]
+                initial_value = dropdown_choices[0]
+                logging.error("Could not load states for dropdown. UI will show error.")
+            else:
+                dropdown_choices = ["Select a state..."] + available_states_list
+                initial_value = dropdown_choices[0]
+        except Exception as e:
+            logging.error(f"Unexpected critical error getting states: {e}", exc_info=True)
+            dropdown_choices = ["Error: Critical failure loading states"]
+            initial_value = dropdown_choices[0]
+
+        # --- Prepare Example Queries ---
+        example_queries_base = [
+            ["What are the rules for security deposit returns?", "California"],
+            ["Can a landlord enter my apartment without notice?", "New York"],
+            ["My landlord hasn't made necessary repairs. What can I do?", "Texas"],
+            ["What are the limits on rent increases in my state?", "Florida"],
+            ["Is my lease automatically renewed if I don't move out?", "Illinois"],
+            ["What happens if I break my lease early?", "Washington"]
         ]
-
-        # Custom CSS (minor adjustments for clarity if needed, your CSS is quite comprehensive)
+        example_queries = []
+        if available_states_list and "Error" not in available_states_list[0]:
+            loaded_states_set = set(available_states_list)
+            example_queries = [ex for ex in example_queries_base if ex[1] in loaded_states_set]
+        if not example_queries:
+             fallback_state = available_states_list[0] if available_states_list and "Error" not in available_states_list[0] else "California"
+             example_queries.append(["What basic rights do tenants have?", fallback_state])
+
+        # --- Refined Custom CSS ---
+        # Focus: Unified background, distinct white cards, proper centering, refined examples table
         custom_css = """
-            /* Your existing CSS here */
-            .gr-form { max-width: 900px; margin: 0 auto; padding: 30px; /* ... */ }
-            .gr-title { font-size: 2.5em; font-weight: 700; color: #1a3c34; /* ... */ }
-            /* ... rest of your CSS ... */
-             .output-markdown {
-                 background: #f9fafb; /* Light mode bg */
-                 color: #1f2937; /* Light mode text */
-                 padding: 20px;
-                 border-radius: 12px;
-                 border: 1px solid #e5e7eb;
-                 font-size: 1.05em; /* Slightly larger text */
-                 line-height: 1.7; /* More spacing */
-                 box-shadow: 0 2px 12px rgba(0, 0, 0, 0.05);
-                 margin-top: 20px; /* Add space above output */
-            }
-            .output-markdown h3 { /* Style the 'Answer for STATE:' heading */
-                 margin-top: 0;
-                 margin-bottom: 15px;
-                 color: #1a3c34; /* Match title color */
-                 border-bottom: 1px solid #e5e7eb;
-                 padding-bottom: 8px;
-            }
-            .output-markdown p { margin-bottom: 1em; }
-            .output-markdown ul, .output-markdown ol { margin-left: 20px; margin-bottom: 1em; }
-            .output-markdown li { margin-bottom: 0.5em; }
-
-             /* Dark mode adjustments */
-             @media (prefers-color-scheme: dark) {
-                 .output-markdown {
-                     background: #374151 !important; /* Dark mode bg */
-                     color: #f3f4f6 !important; /* Dark mode text */
-                     border-color: #4b5563 !important;
-                 }
-                  .output-markdown h3 {
-                       color: #f3f4f6; /* Dark title */
-                       border-bottom: 1px solid #4b5563;
-                  }
-             }
+        @import url('https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500;700&display=swap');
+
+        /* --- Base & Body --- */
+        body, .gradio-container {
+            font-family: 'Roboto', sans-serif !important;
+            background-color: #F5F7FA !important; /* Light grey base background */
+            color: #1F2A44;
+            margin: 0;
+            padding: 0;
+            min-height: 100vh;
+            font-size: 16px; /* Base font size */
+            -webkit-font-smoothing: antialiased;
+            -moz-osx-font-smoothing: grayscale;
+        }
+        * {
+             box-sizing: border-box;
+        }
+
+        /* --- Main Content Container --- */
+        .gradio-container > .flex.flex-col { /* Target the main content column */
+            max-width: 960px; /* Slightly wider max-width */
+            margin: 0 auto !important; /* Center the column */
+            padding: 3rem 1.5rem !important; /* More vertical padding */
+            gap: 2.5rem !important; /* Consistent gap between sections */
+            background-color: transparent !important; /* Ensure container itself is transparent */
+        }
+
+        /* --- Card Styling (Applied to Groups) --- */
+        .card-style {
+            background-color: #FFFFFF !important; /* White background for cards */
+            border: 1px solid #E5E7EB !important; /* Subtle border */
+            border-radius: 12px !important;
+            padding: 2rem !important; /* Consistent padding inside cards */
+            box-shadow: 0 4px 12px rgba(101, 119, 134, 0.08) !important; /* Refined shadow */
+            overflow: hidden; /* Prevent content spill */
+        }
+        /* Remove default Gradio Group padding if using custom padding */
+        .gradio-group {
+            padding: 0 !important;
+            border: none !important;
+            background: none !important;
+            box-shadow: none !important;
+        }
+
+        /* --- Header Section --- */
+        .header-section {
+            background-color: transparent !important; /* Header blends */
+            padding: 1rem 0 !important;
+            text-align: center !important; /* Center align all content */
+            border: none !important;
+            box-shadow: none !important;
+        }
+        .header-logo {
+            font-size: 2.8rem;
+            color: #2563EB;
+            margin-bottom: 0.75rem;
+            display: block; /* Ensure centering */
+        }
+        .header-title {
+            font-size: 2rem; /* Larger title */
+            font-weight: 700;
+            color: #111827; /* Darker title */
+            margin: 0 0 0.25rem 0;
+        }
+        .header-tagline {
+            font-size: 1.1rem;
+            color: #4B5563;
+            margin: 0;
+        }
+
+        /* --- Introduction Section --- */
+        /* Uses card-style defined above */
+        .intro-card h3 {
+            font-size: 1.5rem;
+            font-weight: 600;
+            color: #0369A1; /* Blue heading */
+            margin: 0 0 1rem 0;
+            padding-bottom: 0.5rem;
+            border-bottom: 1px solid #E0F2FE; /* Light blue underline */
+        }
+        .intro-card p {
+            font-size: 1rem;
+            line-height: 1.6;
+            color: #374151; /* Standard text color */
+            margin: 0 0 0.75rem 0;
+        }
+        .intro-card a {
+            color: #0369A1;
+            text-decoration: underline;
+            font-weight: 500;
+        }
+        .intro-card a:hover { color: #0284C7; }
+        .intro-card strong { font-weight: 600; color: #1F2A44; }
+
+        /* --- Input Form Section --- */
+        /* Uses card-style */
+        .input-form-card h3 {
+            font-size: 1.4rem;
+            font-weight: 600;
+            color: #1F2A44;
+            margin: 0 0 1.75rem 0;
+            padding-bottom: 0.75rem;
+            border-bottom: 1px solid #E5E7EB;
+        }
+        .input-field-group { margin-bottom: 1.5rem; }
+        .input-row { display: flex; gap: 1.5rem; flex-wrap: wrap; margin-bottom: 1.5rem; }
+        .input-field { flex: 1; min-width: 220px; }
+
+        /* Input Elements */
+        .gradio-textbox textarea, .gradio-dropdown select, .gradio-textbox input[type=password] {
+            border: 1px solid #D1D5DB !important;
+            border-radius: 8px !important;
+            padding: 0.8rem 1rem !important;
+            font-size: 1rem !important; /* Make inputs slightly larger */
+            background-color: #F9FAFB !important;
+            color: #1F2A44 !important;
+            transition: border-color 0.2s ease, box-shadow 0.2s ease;
+            width: 100% !important;
+        }
+        .gradio-textbox textarea { min-height: 90px; }
+        .gradio-textbox textarea:focus, .gradio-dropdown select:focus, .gradio-textbox input[type=password]:focus {
+            border-color: #2563EB !important;
+            box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.15) !important;
+            outline: none !important;
+            background-color: #FFFFFF !important;
+        }
+        .gradio-input-label, .gradio-output-label { /* Label styling */
+            font-size: 0.9rem !important;
+            font-weight: 500 !important;
+            color: #374151 !important;
+            margin-bottom: 0.5rem !important;
+            display: block !important;
+        }
+        .gradio-input-info { /* Info text */
+            font-size: 0.85rem !important;
+            color: #6B7280 !important;
+            margin-top: 0.3rem;
+        }
+
+        /* Buttons */
+        .button-row { display: flex; gap: 1rem; margin-top: 1.5rem; flex-wrap: wrap; justify-content: flex-end; }
+        .gradio-button {
+            border-radius: 8px !important; padding: 0.75rem 1.5rem !important; font-size: 0.95rem !important;
+            font-weight: 500 !important; border: none !important; cursor: pointer;
+            transition: background-color 0.2s ease, transform 0.1s ease, box-shadow 0.2s ease;
+        }
+        .gradio-button:hover:not(:disabled) { transform: translateY(-1px); box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1); }
+        .gradio-button:active:not(:disabled) { transform: scale(0.98); box-shadow: none; }
+        .gradio-button:disabled { background: #E5E7EB !important; color: #9CA3AF !important; cursor: not-allowed; }
+        .gr-button-primary { background-color: #2563EB !important; color: #FFFFFF !important; }
+        .gr-button-primary:hover:not(:disabled) { background-color: #1D4ED8 !important; }
+        .gr-button-secondary { background-color: #F3F4F6 !important; color: #374151 !important; border: 1px solid #D1D5DB !important; }
+        .gr-button-secondary:hover:not(:disabled) { background-color: #E5E7EB !important; border-color: #9CA3AF !important; }
+
+        /* --- Output Section --- */
+        /* Uses card-style */
+        .output-card .response-header { /* Style the H3 we add in Python */
+            font-size: 1.3rem;
+            font-weight: 600;
+            color: #1F2A44;
+            margin: 0 0 0.75rem 0;
+        }
+        .output-card .divider { /* Style the HR we add */
+            border: none; border-top: 1px solid #E5E7EB; margin: 1rem 0 1.5rem 0;
+        }
+        .output-card .output-content-wrapper { /* Wrapper for the markdown content */
+            font-size: 1rem; line-height: 1.7; color: #374151;
+        }
+        .output-card .output-content-wrapper p { margin-bottom: 1rem; }
+        .output-card .output-content-wrapper ul, .output-card .output-content-wrapper ol { margin-left: 1.5rem; margin-bottom: 1rem; padding-left: 1rem; }
+        .output-card .output-content-wrapper li { margin-bottom: 0.5rem; }
+        .output-card .output-content-wrapper strong, .output-card .output-content-wrapper b { font-weight: 600; color: #111827; }
+        .output-card .output-content-wrapper a { color: #2563EB; text-decoration: underline; }
+        .output-card .output-content-wrapper a:hover { color: #1D4ED8; }
+
+        /* Error message styling */
+        .output-card .error-message {
+            background-color: #FEF2F2; border: 1px solid #FECACA; border-left: 4px solid #F87171;
+            border-radius: 8px; padding: 1rem 1.25rem; color: #B91C1C; font-weight: 500; margin-top: 0.5rem;
+        }
+        .output-card .error-details { font-size: 0.9rem; color: #991B1B; margin-top: 0.5rem; font-style: italic; }
+        /* Placeholder text */
+        .output-card .placeholder { color: #9CA3AF; font-style: italic; text-align: center; padding: 2rem 1rem; display: block; }
+
+        /* --- Examples Section --- */
+        /* Uses card-style */
+        .examples-card .gr-examples-header { /* Style the header Gradio adds */
+            font-size: 1.3rem !important; font-weight: 600 !important; color: #1F2A44 !important;
+            margin: 0 0 1.5rem 0 !important; padding-bottom: 0.75rem !important; border-bottom: 1px solid #E5E7EB !important;
+        }
+        /* Style the TABLE generated by gr.Examples */
+        .examples-card .gr-examples-table { border-collapse: collapse !important; width: 100% !important; }
+        .examples-card .gr-examples-table th,
+        .examples-card .gr-examples-table td {
+            text-align: left !important; padding: 0.75rem 1rem !important;
+            border: 1px solid #E5E7EB !important; font-size: 0.95rem !important;
+            color: #374151 !important; background-color: transparent !important;
+        }
+        .examples-card .gr-examples-table th {
+             font-weight: 500 !important; background-color: #F9FAFB !important; color: #1F2A44 !important;
+        }
+        /* Style the example *rows* when clickable */
+         .examples-card .gr-examples-table tr { cursor: pointer; transition: background-color 0.2s ease; }
+         .examples-card .gr-examples-table tr:hover td { background-color: #F3F4F6 !important; }
+
+        /* --- Footer Section --- */
+        .footer-section {
+            background-color: transparent !important;
+            border-top: 1px solid #E5E7EB !important;
+            padding: 2rem 1rem !important;
+            margin-top: 1rem !important; /* Space above footer */
+            text-align: center !important;
+            color: #6B7280 !important;
+            font-size: 0.9rem !important;
+            line-height: 1.6 !important;
+            box-shadow: none !important; border-radius: 0 !important;
+        }
+        .footer-section strong { color: #374151; font-weight: 500; }
+        .footer-section a { color: #2563EB; text-decoration: none; font-weight: 500; }
+        .footer-section a:hover { color: #1D4ED8; text-decoration: underline; }
+
+        /* --- Accessibility & Focus --- */
+        :focus-visible {
+             outline: 2px solid #2563EB !important;
+             outline-offset: 2px;
+             box-shadow: 0 0 0 3px rgba(37, 99, 235, 0.2) !important;
+        }
+        /* Remove default Gradio focus on button internal span */
+        .gradio-button span:focus { outline: none !important; }
+
+        /* --- Responsive Adjustments --- */
+        @media (max-width: 768px) {
+            .gradio-container > .flex.flex-col { padding: 2rem 1rem !important; gap: 2rem !important; }
+            .card-style { padding: 1.5rem !important; }
+            .header-title { font-size: 1.8rem; }
+            .header-tagline { font-size: 1rem; }
+            .input-row { flex-direction: column; gap: 1rem; margin-bottom: 1rem; }
+            .button-row { justify-content: center; }
+        }
+        @media (max-width: 480px) {
+             body { font-size: 15px; }
+            .gradio-container > .flex.flex-col { padding: 1.5rem 1rem !important; gap: 1.5rem !important; }
+            .card-style { padding: 1.25rem !important; border-radius: 10px !important;}
+            .header-logo { font-size: 2.5rem; margin-bottom: 0.5rem;}
+            .header-title { font-size: 1.5rem; }
+            .header-tagline { font-size: 0.95rem; }
+            .intro-card h3, .input-form-card h3, .output-card .response-header, .examples-card .gr-examples-header { font-size: 1.2rem !important; margin-bottom: 1rem !important; }
+            .gradio-textbox textarea, .gradio-dropdown select, .gradio-textbox input[type=password] { font-size: 0.95rem !important; padding: 0.75rem !important; }
+            .gradio-button { width: 100%; padding: 0.7rem 1.2rem !important; font-size: 0.9rem !important; }
+            .button-row { flex-direction: column; gap: 0.75rem; }
+            .footer-section { font-size: 0.85rem; padding: 1.5rem 1rem !important; }
+             .examples-card .gr-examples-table th, .examples-card .gr-examples-table td { padding: 0.6rem 0.8rem !important; font-size: 0.9rem !important;}
+        }
+
+        /* Gradio Specific Overrides (Use sparingly) */
+        /* Force main container gap */
+        .gradio-container > .flex { gap: 2.5rem !important; }
+        /* Ensure no weird margins collapse */
+        .gradio-markdown > *:first-child { margin-top: 0; }
+        .gradio-markdown > *:last-child { margin-bottom: 0; }
+        /* Remove border from dropdown wrapper if needed */
+        .gradio-dropdown { border: none !important; padding: 0 !important; }
+        /* Remove border from textbox wrapper */
+        .gradio-textbox { border: none !important; padding: 0 !important; }
         """
 
-        # Build the Gradio Blocks interface
-        with gr.Blocks(css=custom_css, theme=gr.themes.Soft()) as demo: # Use a slightly different theme
-            gr.Markdown(
-                """
-                <div style="text-align: center;">
-                    <img src="https://img.icons8.com/plasticine/100/000000/document.png" alt="Icon" style="vertical-align: middle; height: 50px;">
-                    <h1 class='gr-title' style='display: inline-block; margin-bottom: 0; vertical-align: middle; margin-left: 10px;'>Landlord-Tenant Rights Bot</h1>
-                </div>
-                <p class='gr-description'>
-                Ask questions about tenant rights and landlord-tenant laws based on state-specific legal documents.
-                Provide your OpenAI API key, select a state, and enter your question.
-                Get your key from <a href='https://platform.openai.com/api-keys' target='_blank'>OpenAI</a>.
-                </p>
-                """
-            )
+        # --- Gradio Blocks Layout ---
+        with gr.Blocks(css=custom_css, title="Landlord-Tenant Rights Assistant") as demo:
+            # The main container class is applied implicitly by Gradio, CSS targets it
 
-            with gr.Column(elem_classes="gr-form"): # Use elem_classes if defined in CSS, otherwise elem_id
-                # Input Components defined *within* gr.Blocks()
-                api_key_input = gr.Textbox(
-                    label="OpenAI API Key",
-                    type="password",
-                    placeholder="Enter your OpenAI API key (e.g., sk-...)",
-                    info="Required to process your query.", # Use info parameter
-                    #elem_classes="input-field" # Use if defined in CSS
-                )
-                query_input = gr.Textbox(
-                    label="Your Question",
-                    placeholder="e.g., What are the rules for security deposit returns?",
-                    lines=4, # Increased lines slightly
-                    info="Enter your question about landlord-tenant law here.",
-                    #elem_classes="input-field"
-                )
-                state_input = gr.Dropdown(
-                    label="Select State",
-                    choices=available_states,
-                    value=available_states[0] if available_states else None, # Default to first state or None
-                    allow_custom_value=False,
-                    info="Select the state your question applies to.",
-                    #elem_classes="input-field"
+            # Header Section (No Card Style)
+            with gr.Group(elem_classes="header-section"): # Use Group for structure, styled via class
+                gr.Markdown(
+                    """
+                    <span class="header-logo">⚖️</span>
+                    <h1 class="header-title">Landlord-Tenant Rights Assistant</h1>
+                    <p class="header-tagline">Your AI-powered guide to U.S. landlord-tenant laws</p>
+                    """, elem_id="app-title"
                 )
 
-                with gr.Row():
-                    clear_button = gr.Button("Clear Inputs", variant="secondary")
-                    submit_button = gr.Button("Submit Query", variant="primary")
-
-                output = gr.Markdown(
-                    label="Answer",
-                    value="Your answer will appear here...", # Initial placeholder text
-                    elem_classes="output-markdown" # Apply custom class for styling
-                )
+            # Introduction Section (Card Style)
+            with gr.Group(elem_classes="card-style intro-card"):
+                gr.Markdown(
+                    """
+            <h3 style="text-align: center;">Discover Your Rights</h3>
 
-                gr.Markdown("---") # Separator
-                gr.Markdown("### Examples")
-                gr.Examples(
-                    examples=example_queries,
-                    inputs=[query_input, state_input], # Examples only fill these two
-                    # outputs=output, # Output is handled by the main submit button click
-                    # fn=query_interface, # Don't run the function directly on example click
-                    # cache_examples=False, # Don't cache example runs if fn were used
-                    label="Click an example to load it",
-                    examples_per_page=5
+            <p>Get accurate, AI-powered answers to your questions about landlord-tenant laws. Select your state, provide an <strong>OpenAI API key</strong>, and ask your question below.</p>
+            <p>Need an API key? <a href='https://platform.openai.com/api-keys' target='_blank'>Get one free here</a> from OpenAI.</p>
+            <p><strong>Note:</strong> This tool is for informational purposes only. Always consult a licensed attorney for legal advice specific to your situation.</p>
+                    """,
+                    elem_id="app-description"
                 )
 
+            # Examples Section (Card Style)
+
+            # Input Form Section (Card Style)
+            with gr.Group(elem_classes="card-style input-form-card"):
+                gr.Markdown("<h3>Query Section</h3>", elem_id="form-heading")
+
+                with gr.Column(elem_classes="input-field-group"):
+                     api_key_input = gr.Textbox(
+                         label="OpenAI API Key", type="password",
+                         placeholder="Enter your API key (e.g., sk-...)",
+                         info="Required to process your question. Securely used per request, not stored.",
+                         elem_id="api-key-input", lines=1
+                     )
+
+                with gr.Row(elem_classes="input-row"):
+                     with gr.Column(elem_classes="input-field"):
+                         query_input = gr.Textbox(
+                             label="Curious about landlord-tenant laws in your state? Ask away!",
+                             placeholder="E.g., What are the rules for security deposit returns in my state?",
+                             lines=4, max_lines=8, elem_id="query-input"
+                         )
+                     with gr.Column(elem_classes="input-field"):
+                        state_input = gr.Dropdown(
+                            label="Select State", choices=dropdown_choices, value=initial_value,
+                            allow_custom_value=False, elem_id="state-dropdown"
+                         )
+
+                with gr.Row(elem_classes="button-row"):
+                    clear_button = gr.Button(
+                        "Clear Inputs", variant="secondary", elem_id="clear-button",
+                        elem_classes=["gr-button-secondary"]
+                    )
+                    submit_button = gr.Button(
+                        "Submit Question", variant="primary", elem_id="submit-button",
+                        elem_classes=["gr-button-primary"]
+                    )
+
+            # Output Section (Card Style)
+            with gr.Group(elem_classes="card-style output-card"):
+                # Wrap the output markdown for better targeting if needed
+                with gr.Column(): # Add column wrapper if needed for spacing/styling
+                    output = gr.Markdown(
+                        value="<div class='placeholder'>The response will appear here after submitting a question.</div>",
+                        elem_id="output-content",
+                        elem_classes="output-content-wrapper" # Apply styling to this wrapper
+                    )
+
+            # Example Questions Section (Card Style)
+            if example_queries:
+                with gr.Group(elem_classes="card-style examples-card"):
+                     gr.Examples(
+                         examples=example_queries,
+                         inputs=[query_input, state_input],
+                         label="Example Sample Questions", # Uses .gr-examples-header class
+                         examples_per_page=6
+                     )
+            else:
+                 with gr.Group(elem_classes="card-style examples-card"): # Still use card style for consistency
+                    gr.Markdown(
+                        "<div class='placeholder'>Sample questions could not be loaded. Please ensure states are available.</div>"
+                    )
 
+            # Footer Section (No Card Style)
+            with gr.Group(elem_classes="footer-section"):
                 gr.Markdown(
                     """
-                    <div class='footnote' style='margin-top: 30px; padding-top: 15px; border-top: 1px solid #e5e7eb; text-align: center; font-size: 0.9em; color: #6c757d;'>
-                    Developed by Nischal Subedi. Follow on
-                    <a href='https://www.linkedin.com/in/nischal1/' target='_blank' style='color: #007bff; text-decoration: none;'>LinkedIn</a> |
-                    Read insights on <a href='https://datascientistinsights.substack.com/' target='_blank' style='color: #007bff; text-decoration: none;'>Substack</a>.
-                    <br>Disclaimer: This bot provides informational summaries based on AI interpretation and retrieved data. It is not a substitute for professional legal advice.
-                    </div>
-                    """
-                 , elem_classes="footnote") # Apply footnote class if defined in CSS
+                    **Disclaimer**: This tool is for informational purposes only and does not constitute legal advice.
+                    <br><br>
+                    Developed by **Nischal Subedi**. Connect on <a href="https://www.linkedin.com/in/nischal1/" target="_blank">LinkedIn</a> or explore insights at <a href="https://datascientistinsights.substack.com/" target="_blank">Substack</a>.
+                    """, elem_id="app-footer"
+                )
 
-            # Connect Actions to Functions
+            # --- Event Listeners ---
             submit_button.click(
-                fn=query_interface,
+                fn=query_interface_wrapper,
                 inputs=[api_key_input, query_input, state_input],
                 outputs=output,
-                api_name="submit_query" # Add API name for potential programmatic use
+                api_name="submit_query"
             )
-            # Clear button clears all inputs and the output
+
             clear_button.click(
-                fn=lambda: ( # Return empty values for each output component
-                        "", # api_key_input
-                        "", # query_input
-                        available_states[0] if available_states else None, # state_input (reset to default)
-                        "Cleared. Ready for new query..." # output
-                        ),
-                inputs=[], # No inputs needed for clear
+                fn=lambda: (
+                    "", "", initial_value,
+                    "<div class='placeholder'>Inputs cleared. Ready for your next question.</div>"
+                ),
+                inputs=[],
                 outputs=[api_key_input, query_input, state_input, output]
             )
 
-        logging.info("Gradio interface created successfully.")
-        return demo # Corrected return variable name
+        logging.info("Refined Gradio interface created successfully.")
+        return demo
 
-
-# Main execution block
+# --- Main Execution Block ---
 if __name__ == "__main__":
-    logging.info("Starting application setup...")
+    logging.info("Starting Landlord-Tenant Rights Bot application...")
     try:
-        # --- Configuration ---
-        PDF_PATH = os.getenv("PDF_PATH", "data/tenant-landlord.pdf") # Use env var or default
-        VECTOR_DB_PATH = os.getenv("VECTOR_DB_PATH", "./vector_db_store") # For persistent DBs
+        SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+        DEFAULT_DATA_DIR = os.path.join(SCRIPT_DIR, "data")
+        DEFAULT_PDF_PATH = os.path.join(DEFAULT_DATA_DIR, "tenant-landlord.pdf")
+        DEFAULT_DB_PATH = os.path.join(DEFAULT_DATA_DIR, "chroma_db")
 
-        # Check if PDF exists
-        if not os.path.exists(PDF_PATH):
-             logging.error(f"FATAL: PDF file not found at the specified path: {PDF_PATH}")
-             logging.error("Please ensure the PDF file exists or set the PDF_PATH environment variable correctly.")
-             # Exit if the core data file is missing
-             exit(1) # Or raise an exception
+        PDF_PATH = os.getenv("PDF_PATH", DEFAULT_PDF_PATH)
+        VECTOR_DB_PATH = os.getenv("VECTOR_DB_PATH", DEFAULT_DB_PATH)
 
+        os.makedirs(os.path.dirname(VECTOR_DB_PATH), exist_ok=True)
+        os.makedirs(os.path.dirname(PDF_PATH), exist_ok=True)
 
-        # --- Initialization ---
-        # Initialize VectorDatabase (using placeholder for now)
-        # Pass path if your implementation uses it (like ChromaDB)
-        vector_db_instance = VectorDatabase(persist_directory=VECTOR_DB_PATH)
+        logging.info(f"Using PDF path: {PDF_PATH}")
+        logging.info(f"Using Vector DB path: {VECTOR_DB_PATH}")
 
-        # Initialize RAGSystem with the database instance
+        if not os.path.exists(PDF_PATH):
+            logging.error(f"FATAL: PDF file not found at the specified path: {PDF_PATH}")
+            print(f"\n--- CONFIGURATION ERROR ---")
+            print(f"The required PDF file ('{os.path.basename(PDF_PATH)}') was not found at:")
+            print(f"  {PDF_PATH}")
+            print(f"Please ensure the file exists or set 'PDF_PATH' environment variable.")
+            print(f"---------------------------\n")
+            exit(1)
+
+        logging.info("Initializing Vector Database...")
+        vector_db_instance = VectorDatabase(persist_directory=VECTOR_DB_PATH)
+        logging.info("Initializing RAG System...")
         rag = RAGSystem(vector_db=vector_db_instance)
 
-        # --- Data Loading ---
-        # Load the PDF data into the vector database
-        # This step is crucial and needs the *real* vector_db.py
-        logging.info(f"Loading data from PDF: {PDF_PATH}")
-        states_loaded = rag.load_pdf(PDF_PATH)
-        if states_loaded == 0 and not isinstance(vector_db_instance, VectorDatabase): # Check if using placeholder
-              logging.warning("PDF loading reported 0 states. Check PDF content and vector_db implementation.")
-              # Decide if you want to proceed without data or halt
+        logging.info(f"Loading/Verifying data from PDF: {PDF_PATH}")
+        states_loaded_count = rag.load_pdf(PDF_PATH)
+        doc_count = vector_db_instance.document_collection.count() if vector_db_instance.document_collection else 0
+        state_count = vector_db_instance.state_collection.count() if vector_db_instance.state_collection else 0
+        total_items = doc_count + state_count
+
+        if total_items > 0:
+            logging.info(f"Data loading/verification complete. Vector DB contains {total_items} items. Found {states_loaded_count} distinct states.")
+        else:
+            logging.warning("Potential issue: PDF processed but Vector DB appears empty. Check PDF content/format and logs.")
+            print("\nWarning: No data loaded from PDF or found in DB. Application might not function correctly.\n")
 
-        # --- Interface Setup & Launch ---
         logging.info("Setting up Gradio interface...")
         app_interface = rag.gradio_interface()
 
-        logging.info("Launching Gradio app...")
-        # Launch the Gradio app
-        # share=True generates a public link (use with caution)
-        # server_name="0.0.0.0" makes it accessible on the network
-        app_interface.launch(server_name="0.0.0.0", server_port=7860, share=False)
-        # For cloud deployments (like Hugging Face Spaces), you might not need server_name/port
+        SERVER_PORT = 7861
+        logging.info(f"Launching Gradio app on http://0.0.0.0:{SERVER_PORT}")
+        print("\n--- Gradio App Running ---")
+        print(f"Access the interface in your browser at: http://localhost:{SERVER_PORT} or http://<your-ip-address>:{SERVER_PORT}")
+        print("--------------------------\n")
+        app_interface.launch(
+            server_name="0.0.0.0", server_port=SERVER_PORT,
+            share=False,
+            # enable_queue=True # Consider for higher traffic
+        )
 
     except FileNotFoundError as fnf_error:
-         logging.error(f"Initialization failed: {str(fnf_error)}")
-         # No need to raise again, already logged. Maybe print a message.
-         print(f"Error: {str(fnf_error)}. Please check file paths.")
+        logging.error(f"Initialization failed due to a missing file: {str(fnf_error)}", exc_info=True)
+        print(f"\n--- STARTUP ERROR: File Not Found ---")
+        print(f"{str(fnf_error)}")
+        print(f"---------------------------------------\n")
+        exit(1)
     except ImportError as import_error:
-         logging.error(f"Import error: {str(import_error)}. Please ensure all required libraries (gradio, langchain, openai, etc.) and the 'vector_db.py' file are installed and accessible.")
-         print(f"Import Error: {str(import_error)}. Check your dependencies.")
+        logging.error(f"Import error: {str(import_error)}. Check dependencies.", exc_info=True)
+        print(f"\n--- STARTUP ERROR: Missing Dependency ---")
+        print(f"Import Error: {str(import_error)}")
+        print(f"Please ensure required libraries are installed (e.g., pip install -r requirements.txt).")
+        print(f"-----------------------------------------\n")
+        exit(1)
+    except RuntimeError as runtime_error:
+        logging.error(f"A runtime error occurred during setup: {str(runtime_error)}", exc_info=True)
+        print(f"\n--- STARTUP ERROR: Runtime Problem ---")
+        print(f"Runtime Error: {str(runtime_error)}")
+        print(f"Check logs for details, often related to data loading or DB setup.")
+        print(f"--------------------------------------\n")
+        exit(1)
     except Exception as e:
-        # Catch any other unexpected errors during setup or launch
         logging.error(f"An unexpected error occurred during application startup: {str(e)}", exc_info=True)
-        print(f"Fatal Error: {str(e)}. Check logs for details.")
+        print(f"\n--- FATAL STARTUP ERROR ---")
+        print(f"An unexpected error stopped the application: {str(e)}")
+        print(f"Check logs for detailed traceback.")
+        print(f"---------------------------\n")
+        exit(1)

requirements.txt

@@ -11,4 +11,4 @@ pandas==2.2.2
 huggingface_hub==0.23.4
 pymupdf==1.24.9
 langchain_community
-# force rebuild
+# force rebuild #1

vector_db.py

@@ -13,7 +13,7 @@ logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(
 class VectorDatabase:
     """Vector database for storing and retrieving tenant rights information from PDF."""
 
-    def __init__(self, persist_directory="./data/chroma_db"):
+    def __init__(self, persist_directory="./chroma_db"):
         """Initialize the vector database."""
         logging.info("Initializing VectorDatabase")
         logging.info(f"NumPy version: {np.__version__}")
@@ -182,7 +182,7 @@ class VectorDatabase:
 if __name__ == "__main__":
     try:
         db = VectorDatabase()
-        pdf_path = "data/tenant-landlord.pdf"
+        pdf_path = "tenant-landlord.pdf"
         db.process_and_load_pdf(pdf_path)
         states = db.get_states()
         print(f"Available states: {states}")