Update app.py

app.py

@@ -10,6 +10,7 @@ from textblob import TextBlob
 import PyPDF2
 import tempfile
 
+# Download the NLTK punkt tokenizer if not already present
 nltk.download("punkt", quiet=True)
 
 ###############################################################################
@@ -23,36 +24,47 @@ https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
 # Initialize your Hugging Face model client
 client = InferenceClient("HuggingFaceH4/zephyr-7b-beta")
 
-def respond(message, history: list[tuple[str, str]], system_message, max_tokens, temperature, top_p, file_content):
+def respond(
+    message,
+    history: list[tuple[str, str]],
+    system_message,
+    max_tokens,
+    temperature,
+    top_p,
+    file_content
+):
     """
     Streams the chat response from the Hugging Face model.
-    The uploaded file's content is appended to the system message context.
-    Yields tokens as they arrive.
+    Includes file content as part of the system message for context.
+    Yields tokens as they arrive, so Gradio can display partial responses.
     """
     # Append file content to the system prompt if available.
     if file_content and file_content.strip():
         system_message = system_message + "\n\nFile content:\n" + file_content
 
-    # Build the messages list.
+    # Build the messages list for the API request
     messages = [{"role": "system", "content": system_message}]
-    for val in history:
-        if val[0]:
-            messages.append({"role": "user", "content": val[0]})
-        if val[1]:
-            messages.append({"role": "assistant", "content": val[1]})
+    for user_msg, assistant_msg in history:
+        if user_msg:
+            messages.append({"role": "user", "content": user_msg})
+        if assistant_msg:
+            messages.append({"role": "assistant", "content": assistant_msg})
     messages.append({"role": "user", "content": message})
 
     response = ""
-    for partial in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
-        stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        token = partial.choices[0].delta.get("content", "")
-        response += token
-        yield response
+    try:
+        for partial in client.chat_completion(
+            messages,
+            max_tokens=max_tokens,
+            stream=True,
+            temperature=temperature,
+            top_p=top_p,
+        ):
+            token = partial.choices[0].delta.get("content", "")
+            response += token
+            yield response
+    except Exception as e:
+        yield f"Error during model response: {e}"
 
 ###############################################################################
 #                    File Upload & Parsing Functionality                      #
@@ -71,7 +83,7 @@ def parse_file(file):
             text = ""
             for page in reader.pages:
                 extracted = page.extract_text() or ""
-                text += extracted
+                text += extracted + "\n"
             return text
         except Exception as e:
             return f"Error reading PDF: {e}"
@@ -93,53 +105,81 @@ def load_files(files):
     return all_text
 
 ###############################################################################
-#                           Gradio UI Layout                                  #
+#                              Gradio UI Layout                               #
 ###############################################################################
 
 with gr.Blocks() as demo:
-    gr.Markdown("# Combined Chat & File Upload App")
+    gr.Markdown("# **Combined Chat & File Upload App**")
     gr.Markdown(
         """
-This app allows you to upload file(s) and chat with an AI assistant that references the uploaded file(s) throughout the conversation.
-- **Step 1:** Upload your file(s) (e.g., PDF or TXT).
-- **Step 2:** Click **Load File(s)** to parse and store the file content.
-- **Step 3:** Chat with the AI—the uploaded file's content will be appended to the context on every prompt.
-"""
+    This app allows you to upload file(s) and chat with an AI assistant that references the uploaded file(s) throughout the conversation.
+
+    - **Step 1:** Upload your file(s) (e.g., PDF or TXT).
+    - **Step 2:** The app will automatically parse and send the file content to the AI.
+    - **Step 3:** Start chatting with the AI—the uploaded file's content will be used as context.
+    """
     )
     
-    # Create a state to store the file's parsed content.
+    # States to hold file content and chat history
     file_content_state = gr.State("")
-
+    chat_history_state = gr.State([])
+    
     with gr.Row():
-        file_input = gr.File(label="Upload File(s)", file_count="multiple")
-        load_button = gr.Button("Load File(s)")
+        file_input = gr.File(label="Upload File(s)", file_count="multiple", type="file")
     
-    # When the Load button is clicked, concatenate file contents into file_content_state.
-    load_button.click(fn=load_files, inputs=file_input, outputs=file_content_state)
+    # Function to handle file uploads and send initial context to AI
+    def handle_file_upload(files):
+        if not files:
+            return "", []
+        file_content = load_files(files)
+        # Optionally, you can generate an initial AI response acknowledging the file upload
+        # For simplicity, we'll just store the file content
+        return file_content, []
     
-    gr.Markdown("## Chat with AI (using the uploaded file's content as context)")
-    # Note: We use Gradio’s ChatInterface which streams responses from the client.
-    demo_chat = gr.ChatInterface(
-        fn=respond,
-        additional_inputs=[
-            gr.Textbox(
-                value="You are a helpful AI assistant that uses the uploaded file's content as context.",
-                label="System message",
-            ),
-            gr.Slider(
-                minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"
-            ),
-            gr.Slider(
-                minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"
-            ),
-            gr.Slider(
-                minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p (nucleus sampling)"
-            ),
-            file_content_state,  # The uploaded file's content is passed into each chat call.
-        ],
-    )
+    file_input.change(fn=handle_file_upload, inputs=file_input, outputs=[file_content_state, chat_history_state])
     
-    demo.launch()
+    with gr.Column():
+        chatbot = gr.Chatbot(label="Chat History")
+        user_input = gr.Textbox(label="Your message", placeholder="Type your message here and press Enter...")
     
-if __name__ == "__main__":
-    demo.launch()
+    def handle_user_message(user_message, chat_history, file_content):
+        if not user_message.strip():
+            return "", chat_history  # Ignore empty messages
+        
+        # Append the user's message to the chat history
+        chat_history.append((user_message, None))
+        
+        # Generate the AI's response
+        ai_response = ""
+        try:
+            response_generator = respond(
+                message=user_message,
+                history=chat_history,
+                system_message="You are a helpful AI assistant.",
+                max_tokens=512,
+                temperature=0.7,
+                top_p=0.95,
+                file_content=file_content
+            )
+            for response in response_generator:
+                ai_response = response
+                # Update the last entry in chat_history with the AI's response
+                chat_history[-1] = (user_message, ai_response)
+                yield "", chat_history  # Clear the input and update the chat
+        except Exception as e:
+            chat_history[-1] = (user_message, f"Error: {e}")
+            yield "", chat_history
+    
+    # Use Gradio's `submit` event on the textbox to handle messages
+    user_input.submit(
+        handle_user_message,
+        inputs=[user_input, chat_history_state, file_content_state],
+        outputs=[user_input, chatbot],
+        queue=False
+    )
+    
+    # Alternatively, use a button to send messages (optional)
+    # send_button = gr.Button("Send")
+    # send_button.click(handle_user_message, inputs=[user_input, chat_history_state, file_content_state], outputs=[user_input, chatbot])
+
+demo.launch(server_name="0.0.0.0", server_port=7860)