Update app.py

app.py

@@ -1,74 +1,94 @@
-import streamlit as st
-import google.generativeai as genai 
-import sqlite3
+import streamlit as st # This imports the streamlit module for creating the UI
+import google.generativeai as genai # This imports the google generative AI module for using the model
+import sqlite3 # This imports the sqlite3 module for working with the database
+from st.file_uploader import file_uploader # This imports the file_uploader module for uploading images
 
 # Database setup
-conn = sqlite3.connect('chat_history.db')  
-c = conn.cursor()
+conn = sqlite3.connect('chat_history.db') # This creates a connection to the chat_history.db file
+c = conn.cursor() # This creates a cursor object to execute SQL commands
 
 c.execute('''
           CREATE TABLE IF NOT EXISTS history  
           (role TEXT, message TEXT)  
-          ''')
+          ''') # This creates a table named history with two columns: role and message
           
 # Generative AI setup          
-api_key = "AIzaSyC70u1sN87IkoxOoIj4XCAPw97ae2LZwNM"
-genai.configure(api_key=api_key)  
+api_key = "AIzaSyC70u1sN87IkoxOoIj4XCAPw97ae2LZwNM" # This is where you put your API key for the generative AI service
+genai.configure(api_key=api_key) # This configures the genai module with your API key
 
 generation_config = {
-  "temperature": 0.9,
-  "max_output_tokens": 500  
+  "temperature": 0.9, # This is a parameter that controls the randomness of the generated text
+  "max_output_tokens": 500 # This is a parameter that limits the maximum number of tokens in the generated text
 }
 
-safety_settings = []
-
-model = genai.GenerativeModel(
-  model_name="gemini-pro",
-  generation_config=generation_config,
-  safety_settings=safety_settings
-)
+safety_settings = [] # This is a list of safety settings that can filter out harmful or inappropriate content
 
 # Streamlit UI
-st.title("Chatbot")   
+st.title("Chatbot") # This displays a title for the UI
 
-chat_history = st.session_state.get("chat_history", [])
+chat_history = st.session_state.get("chat_history", []) # This gets the chat history from the session state or creates an empty list
 
-if len(chat_history) % 2 == 0:
-  role = "user"
+if len(chat_history) % 2 == 0: # This checks if the chat history has an even number of messages
+  role = "user" # This sets the role to user
 else:  
-  role = "model"
+  role = "model" # This sets the role to model
   
-for message in chat_history:
-  r, t = message["role"], message["parts"][0]["text"]  
-  st.markdown(f"**{r.title()}:** {t}")
+for message in chat_history: # This loops through each message in the chat history
+  r, t = message["role"], message["parts"][0]["text"] # This extracts the role and the text from the message
+  st.markdown(f"**{r.title()}:** {t}") # This displays the role and the text in markdown format
   
-user_input = st.text_input("")  
+user_input = st.text_input("") # This creates a text input widget for the user
+
+# File uploader for images
+uploaded_file = st.file_uploader("Upload an image (optional)", accept="image/*") # This creates a file uploader widget for the user to upload an image file
 
-if user_input: 
-  chat_history.append({"role": role, "parts": [{"text": user_input}]})
+if user_input: # This checks if the user has entered some text
+  chat_history.append({"role": role, "parts": [{"text": user_input}]}) # This appends the user input to the chat history
   
-  if role == "user":
-    response = model.generate_content(chat_history)  
-    response_text = response.text
-    chat_history.append({"role": "model", "parts": [{"text": response_text}]}) 
+  if role == "user": # This checks if the role is user
+    # Check if an image is uploaded
+    image_parts = [] # This creates an empty list for the image parts
+    if uploaded_file: # This checks if the user has uploaded a file
+      image_parts.append({ # This appends a dictionary with the image information to the image parts list
+        "mime_type": uploaded_file.type, # This gets the mime type of the file
+        "data": uploaded_file.read() # This reads the bytes of the file
+      })
+    
+    # Choose the model name based on the image parts
+    if image_parts: # This checks if the image parts list is not empty
+      model_name = "gemini-pro-vision" # This sets the model name to gemini-pro-vision
+    else:
+      model_name = "gemini-pro" # This sets the model name to gemini-pro
+
+    # Create the generative model object
+    model = genai.GenerativeModel(
+      model_name=model_name, # This passes the model name to the model object
+      generation_config=generation_config, # This passes the generation config to the model object
+      safety_settings=safety_settings # This passes the safety settings to the model object
+    )
+    
+    # Generate response based on text and image
+    response = model.generate_content(chat_history + image_parts) # This generates a response from the model based on the chat history and the image parts
+    response_text = response.text # This gets the text of the response
+    chat_history.append({"role": "model", "parts": [{"text": response_text}]}) # This appends the response text to the chat history
     
-  st.session_state["chat_history"] = chat_history
+  st.session_state["chat_history"] = chat_history # This updates the session state with the chat history
 
-  for message in chat_history:
-    r, t = message["role"], message["parts"][0]["text"]
-    st.markdown(f"**{r.title()}:** {t}")
+  for message in chat_history: # This loops through each message in the chat history
+    r, t = message["role"], message["parts"][0]["text"] # This extracts the role and the text from the message
+    st.markdown(f"**{r.title()}:** {t}") # This displays the role and the text in markdown format
 
-if st.button("Display History"):
-    c.execute("SELECT * FROM history")
-    rows = c.fetchall()
+if st.button("Display History"): # This creates a button widget for displaying the history
+    c.execute("SELECT * FROM history") # This executes a SQL command to select all the rows from the history table
+    rows = c.fetchall() # This fetches all the rows from the cursor object
 
-    for row in rows:
-        st.markdown(f"**{row[0].title()}:** {row[1]}")
+    for row in rows: # This loops through each row in the rows list
+        st.markdown(f"**{row[0].title()}:** {row[1]}") # This displays the role and the message in markdown format
         
 # Save chat history to database
-for message in chat_history:
+for message in chat_history: # This loops through each message in the chat history
     c.execute("INSERT INTO history VALUES (?, ?)", 
-            (message["role"], message["parts"][0]["text"])) 
-    conn.commit() 
+            (message["role"], message["parts"][0]["text"])) # This executes a SQL command to insert the role and the message into the history table
+    conn.commit() # This commits the changes to the database
 
-conn.close()
+conn.close() # This closes the connection to the database