agents_page/recommended_agent.py

import streamlit as st
from utils.audit.response_llm import generate_response_via_langchain
from textwrap import dedent
import streamlit as st
from langchain_openai import ChatOpenAI
from langchain_mistralai import ChatMistralAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.messages import AIMessage, HumanMessage

#st.set_page_config(page_title="Agents recommandés", page_icon="", layout="wide")
def remove_images_from_content(content):
    filtered_content = {}
    
    for page, data in content.items():
        # Create a new dictionary excluding the "images" key
        filtered_data = {key: value for key, value in data.items() if key != "images"}
        filtered_content[page] = filtered_data
    
    return filtered_content

def get_response(user_query, chat_history, db,llm=None,history_limit=10,stream=True):
    retriever = db.as_retriever()
    context = retriever.invoke(user_query)
    template = """
    Étant donné l'historique de la conversation : {chat_history}, le contexte qui est le document  : {context}, et la question de l'utilisateur : {user_question}, repond comme un expert en agent IA.
    Assurez-vous que la réponse soit adaptée au niveau d'expertise de l'utilisateur et aux spécificités du contexte fourni.

    """

    prompt = ChatPromptTemplate.from_template(template)

    #llm = ChatOpenAI(model="gpt-4o")
    if not llm:
        llm = ChatOpenAI(model="gpt-4o-mini")
    elif llm == "GPT-4o":
        llm = ChatOpenAI(model="gpt-4o")
    elif llm == "Mistral Large 2 (FR)":
        llm = ChatMistralAI(model_name="mistral-large-2407")
    elif llm == "GPT-4o-mini":
        llm = ChatOpenAI(model="gpt-4o-mini")
    elif llm == "Mistral Nemo (FR)":
        llm = ChatMistralAI(model_name="open-mistral-nemo-2407")
    
        
    chain = prompt | llm

    if not stream:
        return chain.invoke({
            "context": context,
            "chat_history": chat_history[-history_limit:],
            "user_question": user_query,
        })
    
    chain = chain | StrOutputParser()

    if history_limit:
        return chain.stream({
            "context": context,
            "chat_history": chat_history[-history_limit:],
            "user_question": user_query,
        })
    
    return chain.stream({
        "context": context,
        "chat_history": chat_history,
        "user_question": user_query,
    })

def handle_display_models(index, models_names):
    model = st.radio("Choisir un modèle",models_names, index=index)
    return model

def recommended_agent_main():
    st.title("Agents recommandés")
    models_names = ["GPT-4o", "GPT-4o-mini","Mistral Nemo (FR)","Mistral Large 2 (FR)"]

    if "chat_history" not in st.session_state:
        st.session_state.chat_history = [
        ]

    if "model" not in st.session_state:
        st.session_state.model = "GPT-4o-mini"

    header = st.container()
    col1, col2 = header.columns([1, 2])

    with col1.popover("Modèles disponibles"):
        new_model = handle_display_models(models_names.index(st.session_state.model), models_names)

    st.session_state.model = new_model
    
    st.markdown(f"- **{st.session_state.model}**")

    if "audit" not in st.session_state or st.session_state.audit == {}:
        st.error("Veuillez d'abord effectuer un audit pour obtenir des recommandations d'agents.")
        return
    
    audit = st.session_state.audit_simplified
    content = st.session_state.audit["content"]

    if "response_llm" not in st.session_state:
        st.session_state.response_llm = ""


    #filter content, delete images if type is pdf
    if audit["type de fichier"] == "pdf":
        content = remove_images_from_content(content)
    #delete audio if type is audio and keep transcript
    elif audit["type de fichier"] == "audio":
        content = content["transcription"]

    ressources = content

    prompt = '''
    Tu es designer en intelligence artificielle (IA) spécialisé dans la création d'agents IA autonomes et performants.

    A partir de ressources fournies par l'utilisateur (texte, documents, images, audio), tu es chargé de réaliser les tâches suivantes :

    A/ Faire un résumé des ressources fournies en 500 caractères maximum

    B/ Suggérer la création d'agents autonomes pour mettre en pratique les informations contenues dans les ressources fournies.

    Tu proposes deux solutions :

    Sol. A : 1 seul agent IA dont tu suggéreras :
            * Nom
            * Rôle
            * Objectifs
            * Outils utilisés par l'agent
            * Tâches réalisées par l'agents
            * Compétences de l'agent (backstory)

    Sol. B : 1 équipe d'agents tu suggéreras :
            * Le nombre d'agents
            * Pour chacune d'eux [Nom, Rôle, Objectifs, Outils utilisés par l'agent, Tâches réalisées par l'agents, Compétences de l'agent (backstory)]

    Une fois ce travail réalisé, tu proposes une série de 3 missions avec objectifs SMART pour chacun des agents  Sol. A et Sol. B en présentation les résultats dans un tableau contenant :
            * Nom de l’agent
            * Objectifs à atteindre

        '''
    
    #display prompt and modify it 
    prompt_modified = st.text_area("Prompt par défaut (que vous pouvez modifier, compléter)", prompt, height=300)
    prompt_modified = dedent(prompt_modified)

    if st.button("Générer les recommandations"):
        resource_prompt = f'''Ressources fournies par l'utilisateur :{ressources}'''
        prompt_modified = f"{prompt_modified}\n{resource_prompt}"
        st.session_state.chat_history = []
        with st.chat_message("AI"):
            st.session_state.response_llm = st.write_stream(generate_response_via_langchain(query=prompt_modified,stream=True))
        
        st.session_state.chat_history.append(AIMessage(content=st.session_state.response_llm))
    
    elif st.session_state.response_llm:
        st.info("la dernière réponse générée est affichée ci-dessous")
        with st.chat_message("AI"):
            st.write(st.session_state.response_llm)
    
    for message in st.session_state.chat_history[1:]:
        if isinstance(message, AIMessage):
            with st.chat_message("AI"):
                st.markdown(message.content)
        elif isinstance(message, HumanMessage):
            with st.chat_message("Moi"):
                st.write(message.content)

    user_query = st.chat_input("Par ici ...")
    if user_query is not None and user_query != "":
        st.session_state.chat_history.append(HumanMessage(content=user_query))

        with st.chat_message("Moi"):
            st.markdown(user_query)
        
        with st.chat_message("AI"):
            st.markdown(f"**{st.session_state.model}**")
    

            response = st.write_stream(get_response(user_query, st.session_state.chat_history,db=st.session_state.vectorstore, llm=st.session_state.model, stream=True))
            st.session_state.chat_history.append(AIMessage(content=response))




recommended_agent_main()