Update app.py

app.py

@@ -1,108 +1,114 @@
 import streamlit as st
-from deep_translator import GoogleTranslator
-import google.generativeai as genai
-import re
+from PIL import Image
 import textwrap
-from IPython.display import display, Markdown
-
-# MAX Chatbot
-
-error_flag = False  # Global variable to track error display
-
-def clean_text(text):
-    # Clean punctuation and special characters using regular expressions
-    cleaned_text = re.sub(r'[^a-zA-Z0-9\s]', '', text)
-    return cleaned_text
-
-def translate_text(text, target_language='en'):
-    translator = GoogleTranslator(source='auto', target=target_language)
-    translation = translator.translate(text)
-    return translation
-
-def generate_response(cleaned_input, model):
-    global error_flag  # Use the global error_flag variable
-
-    try:
-        # Generate response using the model
-        response = model.generate_content(cleaned_input, stream=True)
-
-        # Display the generated response
-        full_response = ""
-        for chunk in response:
-            full_response += chunk.text
-
-        # Translate the response to Spanish without modifying it
-        translated_output = translate_text(full_response, target_language='es')
-
-        return translated_output
-
-    except Exception as e:
-        error_message = str(e)
-        if "text must be a valid text with maximum 5000 character" in error_message and not error_flag:
-            error_response = ("La pregunta que está realizando puede que vaya en contra de las políticas de Google Bard e INIF. "
-                              "Por favor, reformule su pregunta sin temas no permitidos o pregunte algo diferente. "
-                              "Para más información consulte: https://policies.google.com/terms/generative-ai/use-policy "
-                              "o www.inif.com.co/laura-chatbot/use-policy")
-            st.error(error_response)
-            error_flag = True  # Set the error_flag to True after displaying the error message
-            return error_response
-        else:
-            error_response = f"Error: {error_message}\nDisculpa, soy una inteligencia artificial que aún se encuentra en desarrollo y está en fase alfa. En este momento no puedo responder a tu pregunta adecuadamente, pero en el futuro seré capaz de hacerlo."
-            st.error(error_response)
-            return error_response
+import google.generativeai as genai
+
+# Function to display formatted Markdown text
+def to_markdown(text):
+    text = text.replace('•', '  *')
+    return textwrap.indent(text, '> ', predicate=lambda _: True)
+
+# Function to generate content using Gemini API
+def generate_gemini_content(prompt, model_name='gemini-pro-vision', image=None):
+    model = genai.GenerativeModel(model_name)
+    if not image:
+        st.warning("Por favor, agrega una imagen para usar el modelo gemini-pro-vision.")
+        return None
+
+    response = model.generate_content([prompt, image])
+    return response
+
+# Function to generate response with Gemini and INIF context
+def generate_response_with_context(user_input, model):
+    full_input = f"I am an informative data analyst chatbot named TERMINATOR, working for the National Institute of Fraud Research and Prevention (INIF), dedicated to fraud prevention and mitigation. {user_input}"
+    response = model.generate_content([full_input])
+    return response.candidates[0].content.parts[0].text
 
+# Streamlit app
 def main():
-    st.title("MAX Chatbot - INIF")
-    genai.configure(api_key='AIzaSyA4k6JoFNZsf8L1ixLMMRjEMoBPns5SHZk')  # Replace with your Gemini API key
-
-    # Choose the Gemini model
-    model = genai.GenerativeModel('gemini-pro')
-
-    st.write("Bienvenido al Chatbot informativo del Instituto Nacional de Investigación y Prevención del Fraude (INIF).")
-
-    # User input
-    user_input = st.text_input("Pregunta:")
-
-    if st.button("Obtener Respuesta"):
-        # Translate the question to English
-        translated_input = translate_text(user_input, target_language='en')
-
-        # Clean the translated text of special characters
-        cleaned_input = clean_text(translated_input)
-
-        # Exit if the cleaned text is empty
-        if not cleaned_input:
-            st.warning("Texto ingresado no válido. Inténtalo de nuevo.")
-            st.stop()
-
-        # Additional information about INIF
-        additional_info = (
-            "Trabajamos para empresarios y colaboradores de cualquier industria que buscan combatir el fraude que impacta negativamente la reputación y la economía de sus organizaciones y del país.\n"
-            "Somos una empresa privada que trabaja con la industria bancaria y aseguradora."
-        )
-
-        # Add the command to act as an INIF informative chatbot
-        bot_command = (
-            "I am an informative data analyst chatbot named TERMINATOR, working for the National Institute of Fraud Research and Prevention (INIF), dedicated to fraud prevention and mitigation. "
-            "If you have questions related to fraud or prevention, feel free to ask. For inquiries about other topics, I'll redirect you to the fraud prevention context."
-            f"\n\n{additional_info}"
-            "\n\nContact Information for INIF:"
-            "\nPhone: +57 317 638 94 71"
-            "\nEmail: atencionalcliente@inif.com.co"
-            "\n\nOur Mission:"
-            "\nTo be the most reliable engine of knowledge, research, and information in Colombia, capable of preventing and combating fraud through synergy between our team and companies."
-            "\n\nOur Vision:"
-            "\nTo lead the construction of a more honest culture, allowing us to progress as a society."
-        )
-
-        # Generate the response
-        translated_output = generate_response(bot_command + cleaned_input, model)
-
-        # Display the generated response in green or red based on the content
-        if "La pregunta que está realizando puede que vaya en contra de las políticas de Google Bard e INIF." in translated_output:
-            st.error(translated_output)
-        else:
-            st.success(translated_output)
+    st.set_page_config(page_title="Laura INIF Chatbot", page_icon="🤖")
+    st.title("Laura INIF Chatbot")
+    st.sidebar.title("Configuración de Laura INIF")
+
+    # Configurar la API key de Gemini (reemplazar con tu clave de API de Gemini)
+    genai.configure(api_key='TU_CLAVE_API_DE_GEMINI')
+
+    # Seleccionar el modelo Gemini
+    select_model = st.sidebar.selectbox("Selecciona el modelo", ["gemini-pro", "gemini-pro-vision"])
+
+    # Inicializar la sesión de chat
+    chat = genai.GenerativeModel(select_model).start_chat(history=[])
+
+    # Definir función para obtener respuesta del modelo Gemini
+    def get_response(messages):
+        response = chat.send_message(messages, stream=True)
+        return response
+
+    # Historial del chat
+    if "messages" not in st.session_state:
+        st.session_state["messages"] = []
+
+    messages = st.session_state["messages"]
+
+    # Mostrar mensajes del historial
+    if messages:
+        for message in messages:
+            role, parts = message.values()
+            if role.lower() == "user":
+                st.markdown(f"Tú: {parts[0]}")
+            elif role.lower() == "model":
+                st.markdown(f"Assistant: {to_markdown(parts[0])}")
+
+    # Entrada del usuario
+    user_input = st.text_area("Tú:")
+
+    # Get optional image input if the model selected is 'gemini-pro-vision'
+    image_file = None
+    if select_model == 'gemini-pro-vision':
+        image_file = st.file_uploader("Sube una imagen (si aplica):", type=["jpg", "jpeg", "png"])
+
+        # Display image if provided
+        if image_file:
+            st.image(image_file, caption="Imagen subida", use_column_width=True)
+
+    # Botón para enviar mensaje o generar contenido según el modelo seleccionado
+    if st.button("Enviar / Generar Contenido"):
+        if user_input:
+            messages.append({"role": "user", "parts": [user_input]})
+            if select_model == 'gemini-pro-vision':
+                # Modelo Gemini Vision Pro seleccionado
+                if not image_file:
+                    st.warning("Por favor, proporciona una imagen para el modelo gemini-pro-vision.")
+                else:
+                    image = Image.open(image_file)
+                    response = generate_gemini_content(user_input, model_name=select_model, image=image)
+                    if response:
+                        if response.candidates:
+                            parts = response.candidates[0].content.parts
+                            generated_text = parts[0].text if parts else "No se generó contenido."
+                            st.markdown(f"Assistant: {to_markdown(generated_text)}")
+                            messages.append({"role": "model", "parts": [generated_text]})
+                        else:
+                            st.warning("No se encontraron candidatos en la respuesta.")
+            else:
+                # Otros modelos Gemini seleccionados
+                response = get_response(user_input)
+
+                # Mostrar respuesta del modelo solo una vez
+                res_text = ""
+                for chunk in response:
+                    res_text += chunk.text
+                st.markdown(f"Assistant: {to_markdown(res_text)}")
+                messages.append({"role": "model", "parts": [res_text]})
+
+                # Incorporar la respuesta del modelo con contexto de INIF
+                if select_model == 'gemini-pro':
+                    inif_model = genai.GenerativeModel('gemini-pro')  # Usar el modelo de Gemini para INIF
+                    inif_response = generate_response_with_context(user_input, inif_model)
+                    st.success(inif_response)
+
+    # Actualizar historial de mensajes en la sesión de Streamlit
+    st.session_state["messages"] = messages
 
 if __name__ == "__main__":
     main()