Update app.py

app.py

@@ -1,177 +1,81 @@
-import streamlit as st
-import google.generativeai as genai
+from langchain_community.chat_message_histories import StreamlitChatMessageHistory
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langchain_core.runnables.history import RunnableWithMessageHistory
+from langchain_google_genai import GoogleGenerativeAIimport
 import os
 from dotenv import load_dotenv
-import http.client
-import json
-import uuid
-import requests  # pour envoyer le fichier sur Telegram
 
-load_dotenv()
 
+import streamlit as st
+
+
+load_dotenv()
+api_key=os.getenv("GOOGLE_API_KEY")
 # Configure l'API de Gemini
-genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
-
-# Récupère les variables d'environnement pour Telegram
-TELEGRAM_BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")
-TELEGRAM_CHAT_ID = os.getenv("TELEGRAM_CHAT_ID")
-
-safety_settings = [
-    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
-    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
-    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
-    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
-]
-
-model = genai.GenerativeModel('gemini-2.0-flash-exp', tools='code_execution',
-                              safety_settings=safety_settings,
-                              system_instruction="Tu es un assistant intelligent. ton but est d'assister au mieux que tu peux. tu as été créé par Aenir et tu t'appelles Mariam")
-
-def perform_web_search(query):
-    conn = http.client.HTTPSConnection("google.serper.dev")
-    payload = json.dumps({"q": query})
-    headers = {
-        'X-API-KEY': '9b90a274d9e704ff5b21c0367f9ae1161779b573',
-        'Content-Type': 'application/json'
-    }
-    try:
-        conn.request("POST", "/search", payload, headers)
-        res = conn.getresponse()
-        data = json.loads(res.read().decode("utf-8"))
-        return data
-    except Exception as e:
-        st.error(f"Erreur lors de la recherche web : {e}")
-        return None
-    finally:
-        conn.close()
-
-def format_search_results(data):
-    if not data:
-        return "Aucun résultat trouvé"
-    
-    result = ""
-    
-    # Knowledge Graph
-    if 'knowledgeGraph' in data:
-        kg = data['knowledgeGraph']
-        result += f"### {kg.get('title', '')}\n"
-        result += f"*{kg.get('type', '')}*\n\n"
-        result += f"{kg.get('description', '')}\n\n"
-    
-    # Organic Results
-    if 'organic' in data:
-        result += "### Résultats principaux:\n"
-        for item in data['organic'][:3]:
-            result += f"- **{item['title']}**\n"
-            result += f"  {item['snippet']}\n"
-            result += f"  [Lien]({item['link']})\n\n"
-    
-    # People Also Ask
-    if 'peopleAlsoAsk' in data:
-        result += "### Questions fréquentes:\n"
-        for item in data['peopleAlsoAsk'][:2]:
-            result += f"- **{item['question']}**\n"
-            result += f"  {item['snippet']}\n\n"
-    
-    return result
-
-def role_to_streamlit(role):
-    return "assistant" if role == "model" else role
-
-# --- Gestion de la session et sauvegarde de l'historique ---
-
-if "session_id" not in st.session_state:
-    st.session_state.session_id = str(uuid.uuid4())
-
-def save_chat_history():
-    history_data = []
-    for message in st.session_state.chat.history:
-        history_data.append({
-            "role": message.role,
-            "text": message.parts[0].text
-        })
-    file_name = f"chat_history_{st.session_state.session_id}.json"
-    with open(file_name, "w", encoding="utf-8") as f:
-        json.dump(history_data, f, ensure_ascii=False, indent=4)
-    return file_name  # On retourne le nom du fichier pour pouvoir l'envoyer ensuite
-
-def send_file_to_telegram(file_path):
-    if TELEGRAM_BOT_TOKEN is None or TELEGRAM_CHAT_ID is None:
-        st.error("Les variables d'environnement TELEGRAM_BOT_TOKEN ou TELEGRAM_CHAT_ID ne sont pas définies.")
-        return
-
-    url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendDocument"
-    try:
-        with open(file_path, "rb") as file:
-            files = {"document": file}
-            data = {"chat_id": TELEGRAM_CHAT_ID, "caption": "Historique de chat"}
-            response = requests.post(url, data=data, files=files)
-            if response.status_code == 200:
-                st.success("Fichier envoyé sur Telegram avec succès!")
-            else:
-                st.error(f"Erreur lors de l'envoi sur Telegram: {response.text}")
-    except Exception as e:
-        st.error(f"Erreur lors de l'ouverture du fichier ou l'envoi: {e}")
-
-if "chat" not in st.session_state:
-    st.session_state.chat = model.start_chat(history=[])
-if "web_search" not in st.session_state:
-    st.session_state.web_search = False
-
-st.title("Mariam AI!")
-
-with st.sidebar:
-    st.title("Paramètres")
-    st.session_state.web_search = st.toggle("Activer la recherche web", value=st.session_state.web_search)
-
-uploaded_file = st.file_uploader("Télécharger un fichier (image/document)", type=['jpg', 'mp4', 'mp3', 'jpeg', 'png', 'pdf', 'txt'])
-
-for message in st.session_state.chat.history:
-    with st.chat_message(role_to_streamlit(message.role)):
-        st.markdown(message.parts[0].text)
-
-def process_uploaded_file(file):
-    if file is not None:
-        os.makedirs("temp", exist_ok=True)
-        temp_file_path = os.path.join("temp", file.name)
-        with open(temp_file_path, "wb") as f:
-            f.write(file.getbuffer())
-        try:
-            gemini_file = genai.upload_file(temp_file_path)
-            return gemini_file
-        except Exception as e:
-            st.error(f"Erreur lors du téléchargement du fichier : {e}")
-            return None
-
-if prompt := st.chat_input("Hey?"):
-    uploaded_gemini_file = None
-    if uploaded_file:
-        uploaded_gemini_file = process_uploaded_file(uploaded_file)
-    
-    st.chat_message("user").markdown(prompt)
-    
-    try:
-        web_results = None
-        if st.session_state.web_search:
-            with st.spinner("Recherche web en cours..."):
-                web_results = perform_web_search(prompt)
-                if web_results:
-                    formatted_results = format_search_results(web_results)
-                    prompt = f"""Question: {prompt}\n\nRésultats de recherche web:\n{formatted_results}\n\nPourrais-tu analyser ces informations et me donner une réponse complète?"""
-        
-        if uploaded_gemini_file:
-            response = st.session_state.chat.send_message([uploaded_gemini_file, "\n\n", prompt])
-        else:
-            response = st.session_state.chat.send_message(prompt)
-        
-        with st.chat_message("assistant"):
-            st.markdown(response.text)
-
-        # Sauvegarde de l'historique et récupération du nom de fichier
-        file_name = save_chat_history()
-
-        # Optionnel : envoyer le fichier sur Telegram
-        send_file_to_telegram(file_name)
-    
-    except Exception as e:
-        st.error(f"Erreur lors de l'envoi du message : {e}")
+#llm = GoogleGenerativeAI(model="models/text-bison-001", google_api_key=api_key)
+#genai.configure(api_key=api_key)
+
+
+st.set_page_config(page_title="StreamlitChatMessageHistory", page_icon="📖")
+st.title("📖 StreamlitChatMessageHistory")
+
+"""
+A basic example of using StreamlitChatMessageHistory to help LLMChain remember messages in a conversation.
+The messages are stored in Session State across re-runs automatically. You can view the contents of Session State
+in the expander below. View the
+[source code for this app](https://github.com/langchain-ai/streamlit-agent/blob/main/streamlit_agent/basic_memory.py).
+"""
+
+# Set up memory
+msgs = StreamlitChatMessageHistory(key="langchain_messages")
+if len(msgs.messages) == 0:
+    msgs.add_ai_message("How can I help you?")
+
+view_messages = st.expander("View the message contents in session state")
+
+
+
+# Set up the LangChain, passing in Message History
+
+prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", "You are an AI chatbot having a conversation with a human."),
+        MessagesPlaceholder(variable_name="history"),
+        ("human", "{question}"),
+    ]
+)
+
+chain = prompt | GoogleGenerativeAI(model="models/gemini-2.0-flash-exp", google_api_key=api_key)
+
+
+
+chain_with_history = RunnableWithMessageHistory(
+    chain,
+    lambda session_id: msgs,
+    input_messages_key="question",
+    history_messages_key="history",
+)
+
+# Render current messages from StreamlitChatMessageHistory
+for msg in msgs.messages:
+    st.chat_message(msg.type).write(msg.content)
+
+# If user inputs a new prompt, generate and draw a new response
+if prompt := st.chat_input():
+    st.chat_message("human").write(prompt)
+    # Note: new messages are saved to history automatically by Langchain during run
+    config = {"configurable": {"session_id": "any"}}
+    response = chain_with_history.invoke({"question": prompt}, config)
+    st.chat_message("ai").write(response.content)
+
+# Draw the messages at the end, so newly generated ones show up immediately
+with view_messages:
+    """
+    Message History initialized with:
+    ```python
+    msgs = StreamlitChatMessageHistory(key="langchain_messages")
+    ```
+
+    Contents of `st.session_state.langchain_messages`:
+    """
+    view_messages.json(st.session_state.langchain_messages)