Update app.py

app.py

@@ -62,13 +62,19 @@ def vector_database(chunks):
     Creates a FAISS vector database from the document chunks using a
     Hugging Face embeddings model.
     """
-    # Using a sentence-transformer model from Hugging Face for embeddings
+    # Fixed: Using proper parameter name for HuggingFaceInferenceAPIEmbeddings
     embedding_model = HuggingFaceInferenceAPIEmbeddings(
         api_key=os.environ["HUGGINGFACEHUB_API_TOKEN"],
         model_name="sentence-transformers/all-MiniLM-L6-v2"
     )
-    vectordb = FAISS.from_documents(chunks, embedding_model)
-    return vectordb
+    
+    # Add error handling for embedding creation
+    try:
+        vectordb = FAISS.from_documents(chunks, embedding_model)
+        return vectordb
+    except Exception as e:
+        print(f"Error creating vector database: {e}")
+        raise ValueError(f"Failed to create embeddings: {e}")
 
 ## Retriever
 def retriever(file_path):
@@ -81,7 +87,9 @@ def retriever(file_path):
     # Add a check to ensure chunks are not empty
     if not chunks:
         raise ValueError("The uploaded document could not be processed. Please try another file.")
-
+    
+    print(f"Created {len(chunks)} chunks from the document")
+    
     vectordb = vector_database(chunks)
     retriever = vectordb.as_retriever()
     return retriever
@@ -91,58 +99,103 @@ def retriever_qa(file, query):
     """
     Sets up a RetrievalQA chain to answer questions based on the document.
     """
-    # Use the file path from the Gradio file object
-    file_path = file.name if file else None
-    
     # Check if a file was uploaded
-    if not file_path:
+    if not file:
         return "Please upload a valid PDF file before asking a question."
+    
+    # Check if query is provided
+    if not query or query.strip() == "":
+        return "Please enter a question to get started."
 
-    llm = get_llm()
+    # Use the file path from the Gradio file object
+    file_path = file.name if hasattr(file, 'name') else str(file)
+    
     try:
+        llm = get_llm()
         retriever_obj = retriever(file_path)
-    except ValueError as e:
-        return str(e)
+        
+        # Simplified prompt - let the RetrievalQA chain handle the context properly
+        qa = RetrievalQA.from_chain_type(
+            llm=llm,
+            chain_type="stuff",
+            retriever=retriever_obj,
+            return_source_documents=True,
+        )
+        
+        # Create a proper prompt for legal advice
+        legal_prompt = f"""Based on the document content, please provide professional legal guidance for the following question. 
+        Be conversational, clear, and cite relevant sections when possible.
+        
+        Question: {query}
+        
+        Please provide a helpful and accurate response based on the document content."""
+        
+        response = qa.invoke({"query": legal_prompt})
+        
+        # Extract the result
+        result_text = response.get('result', 'No response generated.')
+        
+        # Clean up the response if needed
+        if result_text.startswith("Legal Advisor's Answer:"):
+            result_text = result_text.replace("Legal Advisor's Answer:", "").strip()
+        
+        return result_text
+        
+    except Exception as e:
+        error_msg = str(e)
+        if "API token" in error_msg or "authentication" in error_msg.lower():
+            return "Error: Please check your Hugging Face API token configuration."
+        elif "embedding" in error_msg.lower():
+            return "Error: Failed to create document embeddings. Please try uploading a different PDF file."
+        else:
+            return f"Error processing your request: {error_msg}"
 
-    # Custom prompt to act as a conversational legal advisor
-    prompt_template = f"""
-    You are a friendly and professional legal advisor. Your goal is to provide concise and contextual legal advice based on the provided document.
-    Do not give verbatim answers. Instead, analyze the relevant text and respond in a conversational manner.
-    
-    Context:
-    {file}
-    
-    Question: {query}
-    
-    Legal Advisor's Answer:
+# Create Gradio interface with better error handling
+def create_interface():
     """
-    
-    qa = RetrievalQA.from_chain_type(
-        llm=llm,
-        chain_type="stuff",
-        retriever=retriever_obj,
-        return_source_documents=True,
+    Creates and returns the Gradio interface
+    """
+    interface = gr.Interface(
+        fn=retriever_qa,
+        allow_flagging="never",
+        inputs=[
+            gr.File(
+                label="Upload PDF File", 
+                file_count="single", 
+                file_types=['.pdf']
+            ),
+            gr.Textbox(
+                label="Input Query", 
+                lines=3, 
+                placeholder="Type your legal question here...",
+                info="Ask questions about the uploaded document"
+            )
+        ],
+        outputs=gr.Textbox(
+            label="Legal Advisor's Response", 
+            lines=10,
+            max_lines=20
+        ),
+        title="Nigerian Constitution Legal Advisor Chatbot",
+        description="""
+        Upload a PDF document (like the Nigerian Constitution) and ask legal questions about it. 
+        The AI will analyze the document and provide contextual legal guidance.
+        
+        **Note:** Make sure to set your Hugging Face API token in the environment variables.
+        """,
+        examples=[
+            [None, "What are the fundamental rights guaranteed by this constitution?"],
+            [None, "What is the process for constitutional amendments?"],
+            [None, "What are the powers of the federal government?"]
+        ]
     )
-    
-    # Using a custom prompt template for the LLM
-    response = qa.invoke({"query": prompt_template})
-    
-    # Extract the contextual response from the full LLM output
-    result_text = response['result']
-    return result_text
-
-# Create Gradio interface
-rag_application = gr.Interface(
-    fn=retriever_qa,
-    allow_flagging="never",
-    inputs=[
-        gr.File(label="Upload PDF File", file_count="single", file_types=['.pdf'], type="filepath"),
-        gr.Textbox(label="Input Query", lines=2, placeholder="Type your question here...")
-    ],
-    outputs=gr.Textbox(label="Legal Advisor's Response"),
-    title="Nigerian Constitution Legal Advisor Chatbot",
-    description="Upload the Nigerian Constitution and ask me questions about it. I will provide a conversational and contextual response."
-)
+    return interface
 
 # Launch the app
-rag_application.launch(share=True)
+if __name__ == "__main__":
+    # Check if API token is set
+    if not os.environ.get("HUGGINGFACEHUB_API_TOKEN") or os.environ.get("HUGGINGFACEHUB_API_TOKEN") == "hf_YOUR_HUGGINGFACE_TOKEN":
+        print("WARNING: Please set your actual Hugging Face API token in the HUGGINGFACEHUB_API_TOKEN environment variable")
+    
+    rag_application = create_interface()
+    rag_application.launch(share=True)