Update app.py

app.py

@@ -1,67 +1,78 @@
-import os
-import google.generativeai as genai
 import gradio as gr
+import google.generativeai as genai
+import os
 
-# Configure the API key
-genai.configure(api_key=os.environ["YOUR_API_KEY"])
-
-# Create the model
-generation_config = {
-    "temperature": 1,
-    "top_p": 0.95,
-    "top_k": 64,
-    "max_output_tokens": 8192,
-    "response_mime_type": "text/plain",
-}
+# Configure the Gemini API with your API key
+genai.configure(api_key=os.environ["API_KEY"])
 
-model = genai.GenerativeModel(
-    model_name="gemini-1.5-flash",
-    generation_config=generation_config,
-    # safety_settings can be adjusted
-    # See https://ai.google.dev/gemini-api/docs/safety-settings
-)
+# Initialize the Gemini Generative Model
+model = genai.GenerativeModel("gemini-1.5-flash")
 
-# Function to handle chat
-def chat_with_model(user_input, history):
-    # Update the history with the user's input
-    history.append({"role": "user", "content": user_input})
+def chat_with_gemini(user_input, history):
+    """
+    Generates a response from the Gemini API based on user input and conversation history.
     
-    # Convert history to expected format (list of protos.Content)
-    formatted_history = []
-    for entry in history:
-        # Assuming the message content is a string
-        content = genai.protos.Content(text=entry["content"], role=entry["role"])
-        formatted_history.append(content)
+    Args:
+        user_input (str): The latest message from the user.
+        history (list): The conversation history as a list of tuples.
     
-    # Start or continue the chat session using the formatted history
-    chat_session = model.start_chat(history=formatted_history)
-    response = chat_session.send_message(user_input)
-    # Add the assistant's response to the history
-    history.append({"role": "assistant", "content": response.text})
-    # Format the history for display in Gradio Chatbot
-    messages = []
-    for i in range(0, len(history), 2):
-        user_msg = history[i]["content"]
-        assistant_msg = history[i+1]["content"] if i+1 < len(history) else ""
-        messages.append((user_msg, assistant_msg))
-    return messages, history
+    Returns:
+        tuple: The chatbot's reply and the updated history.
+    """
+    try:
+        # Send the latest message to the Gemini API
+        response = model.generate_content(
+            user_input,
+            generation_config=genai.GenerationConfig(
+                max_output_tokens=150,
+                temperature=0.7
+            )
+        )
+        
+        chatbot_reply = response.text.strip()
+        
+        # Append the user input and chatbot reply to the history
+        history.append((user_input, chatbot_reply))
+        
+        return history, history
+    except Exception as e:
+        error_message = f"An error occurred: {e}"
+        history.append((user_input, error_message))
+        return history, history
 
-# Create Gradio app
-with gr.Blocks() as demo:
-    gr.Markdown("# Chat with Gemini Model")
+with gr.Blocks() as iface:
+    gr.Markdown("# 🗣️ Google Gemini Chatbot")
+    
     chatbot = gr.Chatbot()
-    state = gr.State([])
+    
     with gr.Row():
-        user_input = gr.Textbox(
-            show_label=False,
-            placeholder="Type your message and press Enter"
-        )
-        send_btn = gr.Button("Send")
-    # Event handlers
-    send_btn.click(chat_with_model, [user_input, state], [chatbot, state])
-    user_input.submit(chat_with_model, [user_input, state], [chatbot, state])
-    # Clear input after sending
-    send_btn.click(lambda: "", None, user_input)
-    user_input.submit(lambda: "", None, user_input)
+        with gr.Column(scale=0.85):
+            user_input = gr.Textbox(
+                placeholder="Type your message here...",
+                show_label=False
+            )
+        with gr.Column(scale=0.15):
+            send_button = gr.Button("Send")
+    
+    # State to hold the conversation history
+    history = gr.State([])
+    
+    def respond(message, history_state):
+        """
+        Handles the user message, generates a response, and updates the conversation history.
+        
+        Args:
+            message (str): The user's message.
+            history_state (list): The current conversation history.
+        
+        Returns:
+            tuple: Updated conversation history for display.
+        """
+        updated_history, new_history = chat_with_gemini(message, history_state)
+        return updated_history, new_history
+    
+    send_button.click(respond, inputs=[user_input, history], outputs=[chatbot, history])
+    user_input.submit(respond, inputs=[user_input, history], outputs=[chatbot, history])
 
-demo.launch()
+if __name__ == "__main__":
+    iface.launch()