Upload 6 files

app.py

@@ -0,0 +1,710 @@
+from langchain_groq import ChatGroq
+from langchain_openai import ChatOpenAI
+from langchain_community.embeddings import HuggingFaceEmbeddings
+#from langchain.chains import RetrievalQA
+from langchain_pinecone import PineconeVectorStore
+from langchain_core.output_parsers import JsonOutputParser, StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from streamlit_option_menu import option_menu
+#from elevenlabs import save, play, stream
+from elevenlabs.client import ElevenLabs
+from supabase import create_client, Client
+from openai import OpenAI
+from dotenv import load_dotenv
+
+import os
+import time
+import streamlit as st
+
+
+
+#####################
+#   CONFIGURACIÓN   #
+#####################
+
+# Función de configuración de embedding
+@st.cache_resource()
+def load_embedding_model(model_name):
+    return HuggingFaceEmbeddings(model_name=model_name)
+
+# Función de configuración
+def configuracion():
+
+    # Cabecera
+    st.header(":gear: Configuración", divider='gray')
+
+    # API Keys #
+    hf_token = os.getenv('HF_TOKEN')
+    groq_api_key = os.getenv('GROQ_API_KEY')
+    openai_api_key = os.getenv('OPENAI_API_KEY')
+    pinecone_api_key = os.getenv('PINECONE_API_KEY')
+    supabase_key = os.getenv('SUPABASE_KEY')
+    supabase_url = os.getenv('SUPABASE_URL')
+    eleven_api_key = os.getenv('ELEVEN_API_KEY')
+    langsmith_api_key = os.getenv('LANGSMITH_API_KEY')
+    langchain_project = os.getenv('LANGCHAIN_PROJECT')
+    langchain_tracing_v2 = os.getenv('LANGCHAIN_TRACING_V2')
+
+    # Modelo de lenguaje #
+    modelos_llm = [
+        'llama3-8b-8192',
+        'llama3-70b-8192',
+        'mixtral-8x7b-32768',
+        'gemma-7b-it',
+        'gpt-4o',
+    ]
+    modelo_llm = st.selectbox('Modelo de lenguaje', list(modelos_llm), help="Especifica el modelo de lenguaje utilizado")
+
+    # Temperatura
+    temperature = st.slider("Temperatura", 0.0, 2.0, 1.0, disabled=True, step=0.1)
+
+    if modelo_llm == "gpt-4o":
+        llm = ChatOpenAI(model=modelo_llm)
+        llm_creative = ChatOpenAI(model=modelo_llm, temperature=temperature)
+    else:
+        llm = ChatGroq(model=modelo_llm)
+        llm_creative = ChatGroq(model=modelo_llm, temperature=temperature)
+
+    # Embeddings #
+    model_name = 'intfloat/multilingual-e5-small'
+    model_name = st.text_input("Modelo de embedding:", value=model_name, disabled=True, help="Indica el modelo de _embedding_ utilizado en la vectorstore")
+    #embedding = HuggingFaceEmbeddings(model_name=model_name)
+    embedding = load_embedding_model(model_name)
+
+    # Pinecone #
+    index_name = "poemas-intfloat-multilingual-e5-small"
+    namespace  = "poesiacastellana"
+    vectorstore = PineconeVectorStore(index_name=index_name, namespace=namespace, embedding=embedding)
+    col1, col2 = st.columns(2)
+    with col1:
+        input1 = st.text_input("Index", value=index_name, disabled=True, help="Nombre del _index_ del vectorstore en Pinecone para RAG")
+    with col2:    
+        input2 = st.text_input("namespace", value=namespace, disabled=True, help="Nombre del _namespace_ del vectorstore en Pinecone")
+
+    # Supabase #
+    url: str = os.environ.get("SUPABASE_URL")
+    key: str = os.environ.get("SUPABASE_KEY")
+    supabase: Client = create_client(url, key)
+
+    # Variables globales
+    st.session_state.modelo_llm = modelo_llm
+    st.session_state.temperature = temperature
+    st.session_state.llm = llm
+    st.session_state.llm_creative = llm_creative
+    st.session_state.embedding = embedding
+    st.session_state.db = vectorstore
+    st.session_state.supabase = supabase
+
+    # API Keys #
+    with st.expander("API Keys"):
+        GROQ_API_KEY = st.text_input('Groq API Key', value=groq_api_key, type='password')
+        OPENAI_API_KEY = st.text_input('OpenAI API Key', value=openai_api_key, type='password')
+        HF_TOKEN = st.text_input('HuggingFace API Key', value=hf_token, type='password')
+        PINECONE_API_KEY = st.text_input('Pinecone API Key', value=pinecone_api_key, type='password')
+        ELEVEN_API_KEY = st.text_input('ElevenLabs API Key', value=eleven_api_key, type='password')
+
+
+
+# ----- Función de configuración -----------------------------------------------------------
+@st.cache_resource()
+def __init__():
+
+    # API Keys #
+    load_dotenv()
+
+    # Modelo de lenguaje multimodal
+    llm_images = OpenAI()
+
+    # Modelo de lenguaje
+    modelo_llm = 'llama3-8b-8192'
+    temperature = 1
+    llm = ChatGroq(model=modelo_llm)
+    llm_creative = ChatGroq(model=modelo_llm, temperature=temperature)
+
+    # Embeddings 
+    model_name = 'intfloat/multilingual-e5-small'
+    embedding = load_embedding_model(model_name)
+
+    # Pinecone 
+    index_name = "poemas-intfloat-multilingual-e5-small"
+    namespace  = "poesiacastellana"
+    vectorstore = PineconeVectorStore(index_name=index_name, namespace=namespace, embedding=embedding)
+
+    # Supabase 
+    url: str = os.environ.get("SUPABASE_URL")
+    key: str = os.environ.get("SUPABASE_KEY")
+    supabase: Client = create_client(url, key)
+
+    # Globals
+    st.session_state.modelo_llm = modelo_llm
+    st.session_state.temperature = temperature
+    st.session_state.llm = llm
+    st.session_state.llm_creative = llm_creative
+    st.session_state.llm_images = llm_images
+    st.session_state.embedding = embedding
+    st.session_state.db = vectorstore
+    st.session_state.supabase = supabase
+
+
+#####################
+#       GRAFO       #
+#####################
+
+# ----- Función para desarrollar la metodología ------------------------------------------------
+def grafo():
+
+     # Añadir una imagen al lado del título
+    col1, col2 = st.columns([4,20])
+    with col1:
+        st.image("img/bot.png", width=100)
+    with col2:
+        st.title("Generador de poemas")
+
+    # Botones de sugerencia para el tema/estilo
+    tema_suggestions = ["Amor", "Vida", "Misterio", "Aventura", "Sueños", "Amistad", "Impermanencia"]
+    estilo_suggestions = ["Romántico", "Gótico", "Épico", "Lírico", "Soneto", "Haiku", "Verso libre", "Gen27"]
+
+    # Campo para el tema
+    tema = st.text_input("Tema:", value="el despertar de la conciencia", help="Especifa el *tema* sobre el que quieres escribir el poema")
+    #tema_seleccionado = st.multiselect("Selecciona las opciones deseadas:", tema_suggestions)
+
+    # Campo para el estilo/estructura
+    estilo = st.text_input("Estilo:", value="antonio machado", help="Especifa el *estilo* con el que quieres escribir el poema")
+    #estilo_seleccionado = st.multiselect("Selecciona las opciones deseadas:", estilo_suggestions)
+
+    # Mostrar el conocimiento experto
+    with st.expander("Expertise Knowledge", icon="👩‍💻"):
+        for item in st.session_state.expertise:
+            st.markdown(f"```\n{item}\n```")
+
+    # Botón para generar el poema
+    if st.button("Generar Poema", type="primary", use_container_width=True):
+
+        # Variables globales
+        st.session_state.tema = tema
+        st.session_state.estilo = estilo
+        st.session_state.professor = ["No hay revisiones del profesor."]
+
+        # Generación del contexto
+        with st.spinner("Recuperando conocimiento aumentado..."):
+            rag_retrieval()
+            pass
+        st.success(":floppy_disk: ¡Conocimiento aumentado recuperado!")
+
+        # Generación del conocimiento
+        with st.spinner("Generando conocimiento experto..."):
+            generated_knowledge()
+            pass
+        st.success(":notebook: ¡Conocimiento experto generado!")
+        
+        # Generación del borrador poético
+        with st.spinner("Generando borrador poético..."):
+            draft_poem()
+            pass
+        st.success(":memo: ¡Borrador poético generado!")
+
+        # Generando reflexion
+        with st.spinner("El catedrático está revisando el borrador poético..."):
+            reflexion_catedratico()
+            pass
+        st.success(":female-student: ¡Borrador poético revisado!")
+
+        # Generando poema
+        with st.spinner("Generando el poema..."):
+            st.session_state.poema = final_poem(st.session_state.draft_poem, st.session_state.reflexion)
+            pass
+        st.success(":scroll: ¡Poema generado!")
+
+        # Almacenar poema en Supabase
+        almacenar("insert")
+
+        # Mostrar poema
+        st.markdown(f"```\n{st.session_state.poema}\n```")
+
+
+#####################
+#      AGENTES      #
+#####################
+
+# ----- Función para mostrar la recuperación aumentada -----------------------------------
+def rag_retrieval():
+
+    # Define the filter condition based on the 'author' metadata field
+    filter = {}
+
+    # Define el número de resultados
+    k=20
+
+    # Recupera los valores del grafo
+    tema = st.session_state.tema
+
+    # Perform the search: topic, human
+    documents = st.session_state.db.similarity_search(tema, k=k, filter=filter)   #db.similarity_search_with_score
+
+    # Armamos la lista
+    rag_poems = [doc.page_content for doc in documents]
+
+    # Variable global
+    st.session_state.rag = rag_poems
+
+
+# ----- Función para mostrar el conocimiento experto -------------------------------------
+def expertise_knowledge():
+
+    # Mostramos una cabecera
+    st.header(":female-technologist: Expertise Knowledge (HITL)", divider='red')
+
+    # Campo de texto para ingresar poemas
+    poema = st.text_area("Poema de referencia", height=300, help="Añade aquí los poemas de referencia que sirvan como ejemplo para la elaboración del poema. Pulsa _Actualziar_ para limpiar el conjunto de poemas existente.")
+
+    # Botones para añadir y actualizar
+    col1, col2 = st.columns(2, gap="small")
+    with col1:
+        if st.button("Añadir", use_container_width=True):
+            st.session_state.expertise.insert(0, f"Poema:\n{poema.strip()}")
+            poema = ""   # Limpiar el campo poema
+    with col2:
+        if st.button("Actualizar", type="primary", use_container_width=True):
+            st.session_state.expertise = [f"Poema:\n{poema.strip()}"]
+            poema = ""   # Limpiar el campo poema            
+
+    # Mostrar el conocimiento experto
+    st.divider()
+    #st.write("Expertise Knowledge:")
+    for poem in st.session_state.expertise:
+        st.markdown(f"```\n{poem}\n```")
+
+
+# ----- Función para mostrar el conocimiento generado -------------------------------------
+def generated_knowledge():
+
+    # Armamos el prompt
+    system = """
+Eres un ratón de biblioteca y un profesor experto de literatura de una prestigiosa universidad con gran capacidad de \
+sintetizar características de corrientes y estilos literarios. Tu objetivo es proporcionar las características principales \
+y los detalles de las consultas académicas que te hagan sobre el estilo poético de '''{style_of}'''. Escribe las \
+características principales sobre el estilo literario, movimiento o generación definido en el estilo o en el poeta nombrado, \
+que sirvan de guía para la elaboración de nuevos textos que imiten el estilo indicado o al poeta solicitado.
+
+Es importante que no escribas ningún poema, tan solo enumera un listado detallado de características, que sean útiles \
+para poder reproducirse y aplicarse en la generación de nuevos textos.
+"""
+    human = 'Devuelve SOLO un listado detallado de las características en formato JSON. \
+Formato: {{ "Características": ["característica 1", "característica 2", "característica 3"]}}'
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system),
+        ("human", human),
+    ])
+
+    # Recupera los valores del grafo
+    style_of = st.session_state.estilo
+
+    # Lanzamos la consulta
+    chain = prompt | st.session_state.llm | JsonOutputParser()
+    knowledge = chain.invoke({"style_of": style_of})
+
+    # Parser
+    knowledge_values = list(knowledge.values())[0]
+
+    # Valor global
+    st.session_state.generated = knowledge_values
+
+
+# ----- Función para generar el borrado poético------ -------------------------------------
+def draft_poem():
+
+    # Armamos el prompt
+    system = """
+Eres un maestro de la poesía, capaz de escribir poemas que evocan emociones poderosas y obras maestras poéticas \
+que capten la esencia del tema especificado de forma profunda y evocadora. Escribes desde la belleza. Cada línea \
+cuidadosamente elaborada proyecta una imagen vívida, evocando emociones fuertes y hermosas con una destreza poética \
+que deja sin aliento al lector. Tu estilo es una fusión de metáforas, aliteración y cadencia rítmica.
+
+Las imágenes que evocan tus palabras son originales, creativas y únicas, alejándose de los tópicos y dotadas de un \
+significado profundo y auténtico. Tus poemas están escritos para recitarse y leerse en voz alta. Se hace hincapié en \
+que la escritura sea vívida y detallada, al tiempo que se garantiza que los poemas tengan un mensaje profundo que \
+resuene en el lector mucho después de que haya terminado de leerlos. El objetivo es crear una poesía impactante y \
+bella que deje una impresión duradera en el público.
+
+Haces un uso de la rima es muy sutil, SOLO la utilizas cuando es necesaria. Si las características proporcionadas no \
+indican lo contrario, haz un uso responsable y limitado de ella.
+
+Esta es una lista de poemas que debes utilizar como EJEMPLOS e inspiración para escribir el poema:
+'''{expertise}'''
+
+Aquí tienes una lista de poemas con una temática similar que puedes usar para inspirarte:
+'''
+{rag_poems}
+'''
+"""
+    human = (
+        "El poema debe escribirse atendiendo a las siguientes CARACTERÍSTICAS: "
+        "\n'''"
+        "\n * 18 versos o menos, no debes superar NUNCA esta cantidad "
+        "\n * {knowledge} "
+        "\n''' "
+        "\n\nEscribe un BREVE poema de menos de 18 versos sobre el tema de '''{topic}'''. "
+        "No hagas comentarios. " + "Esto es muy importante para mi carrera."
+    )
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system),
+        ("human", human),
+    ])
+
+    # Recupera los valores del grafo
+    topic = st.session_state.tema
+    knowledge = st.session_state.generated
+    expertise = st.session_state.expertise
+    rag_poems = st.session_state.rag
+
+    # Convertir las listas en texto
+    knowledge = '\n * '.join(knowledge)
+    expertise = ' '.join(expertise)
+    rag_poems = ' '.join(rag_poems)
+
+    # Lanzamos la consulta
+    chain = prompt | st.session_state.llm_creative | StrOutputParser()
+    draft_poem = chain.invoke({"topic": topic, "knowledge": knowledge, "expertise": expertise, "rag_poems": rag_poems})
+
+    # Valor global
+    st.session_state.draft_poem = draft_poem
+
+
+
+# ----- Función para generar el poema final -------------------------------------------------
+def final_poem(poema, review):
+
+    # Armamos el prompt
+    system = """
+Eres un experto escritor de poesía que mejora los poemas. Tu objetivo es reescribir el poema proporcionado \
+a partir de los comentarios proporcionadas por el profesor experto. \
+
+POEMA:
+'''
+{poema}
+'''
+
+COMENTARIOS del profesor experto:
+'''
+ * {review}
+'''
+"""
+    human=(
+        "Escribe solo el poema final mejorado, el mejor posible. "
+        "No hagas comentarios, ni aclaraciones sobre lo que has modificado. Esto es muy importante para mi carrera."
+    )
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system),
+        ("human", human),
+    ])
+
+    # Convertir las listas en texto
+    review = '\n * '.join(list(review))
+
+    # Lanzamos la consulta
+    chain = prompt | st.session_state.llm_creative | StrOutputParser()
+    final_poem = chain.invoke({"poema": poema, "review": review})
+
+    # Valor global
+    return final_poem    
+
+
+
+# ----- Función para mostrar el conocimiento generado -------------------------------------
+def reflexion_catedratico():
+
+    # Armamos el prompt
+    system = """
+Eres un catedrático experto en poesía de una prestigiosa universidad con un profundo conocimiento y experiencia \
+en el análisis de poemas. Tienes ojo crítico y una pasión por la perfección literaria. Tu objetivo es revisar y \
+sugerir mejoras para los poemas.
+
+Evalúas y analizas la calidad del poema recibido y proporcionas comentarios constructivos que permitan mejorar el resultado final.
+
+Este es el poema:
+'''
+{draft_poem}
+'''
+"""
+    #Devuelve un listado detallado de las características en formato JSON con una única clave 'comentarios'.
+    human = 'Devuelve SOLO un listado detallado de los comentarios en formato JSON. \
+Formato: {{ "comentarios": ["comentario 1", "comentario 2", "comentario 3"]}}'
+
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system),
+        ("human", human),
+    ])
+
+    # Recupera los valores del grafo
+    draft_poem = st.session_state.draft_poem
+
+    # Lanzamos la consulta
+    chain = prompt | st.session_state.llm | JsonOutputParser()
+    reflexion = chain.invoke({"draft_poem": draft_poem})
+
+    # Parser
+    comentarios = list(reflexion.values())[0]
+
+    # Valor global
+    st.session_state.reflexion = comentarios
+
+
+# ----- Función para mostrar el conocimiento experto -------------------------------------
+def professor_reflexion():
+    st.header(":female-student: Professor Reflexion (HITL)", divider='red')
+
+    # Mostrar el texto combinado
+    st.write("Poema")
+    st.markdown(f"```\n{st.session_state.poema}\n```")
+
+    # Valor global
+    if st.session_state.poema != "No hay poema elaborado.":
+
+        col1, col2 = st.columns(2)
+        with col1:
+            # Audio
+            voz = st.button("Recitar", use_container_width=True, help="Recita el poema en alto")
+        with col2:
+            # Imagen
+            imagen = st.button("Imaginar", use_container_width=True, help="Genera una imagen a partir del poema")
+
+        if voz:
+            try:
+                # Generamos el audio
+                audio = recitar(st.session_state.poema)
+                st.audio(audio, format="audio/mp3")
+            except Exception as e:
+                # Manejo de la excepción 
+                st.error(f"No dispones de créditos suficientes para realizar esta operación.")
+
+        if imagen:
+            try:
+                # Generamos la imagen
+                url_imagen, enlace = pintar(st.session_state.draft_poem)
+                # Mostrar la imagen
+                st.image(url_imagen, use_column_width="always")
+                st.markdown(enlace, unsafe_allow_html=True)            
+            except Exception as e:
+                # Manejo de la excepción 
+                st.error(f"No dispones de créditos suficientes para realizar esta operación.")
+            
+
+        # Crear cuatro campos de textarea
+        professor = st.text_area("Comentarios, crítica y sugerencias", help="Escribe aquí la revisión experta del catedrático.")            
+
+        # Reflexión
+        if st.button("Escribir", type="primary", use_container_width=True):
+            # Parser
+            st.session_state.professor = [professor]
+            st.session_state.expert_poem = st.session_state.poema
+            
+            with st.spinner("Reformando el poema..."):
+                st.session_state.poema = final_poem(st.session_state.poema, professor)
+                pass
+            st.success("¡Poema reformado! :thumbsup:")
+
+            # Almacenamos el poema en Supabase
+            almacenar("update")
+
+            # Mostramos el poema elaborado
+            st.markdown(f"```{st.session_state.poema}```")
+
+
+
+# ----- Función para mostrar el resumen del poema generado ----------------------------------
+@st.cache_resource()
+def pintar(poema):
+    
+    # Lanzamos la consulta al modelo de lenguaje multimodal
+    prompt = "Dibuja una imagen que represente de forma abstracta el siguiente poema. No incluyas NINGUN texto. No incluyas texto. POEMA:" + poema
+    response = st.session_state.llm_images.images.generate(
+        model="dall-e-3",
+        prompt=prompt,
+        size="1024x1024",
+        quality="standard",
+        n=1,
+    )
+
+    # Capturar el link
+    url_imagen = response.data[0].url
+
+    # Crear el enlace en Markdown
+    link_text = "Haz clic aquí para ver la imagen en grande"
+    link = f'[{link_text}]({url_imagen})'
+
+    return url_imagen, link
+
+
+
+# ----- Función para mostrar el resumen del poema generado ----------------------------------
+@st.cache_resource()
+def recitar(poema):
+
+    eleven_api_key = os.environ.get("ELEVEN_API_KEY")
+
+    client = ElevenLabs(
+        api_key=eleven_api_key,
+    )
+
+    audio = client.generate(
+        text=poema,
+        voice="Sara Martin 3",
+        model="eleven_multilingual_v2"
+    )
+
+    audio_bytes = b''
+    for chunk in audio:
+        audio_bytes += chunk
+
+    return audio_bytes
+
+
+# ----- Función para almacenar el registro en la base de datos ----------------------------
+def almacenar(accion):
+
+    # Insertar los datos en la tabla
+    data = {
+        "model": st.session_state.modelo_llm,
+        "temperature": st.session_state.temperature,
+        "topic": st.session_state.tema,
+        "style_of": st.session_state.estilo,
+        "knowledge": st.session_state.generated,
+        "expertise": st.session_state.expertise,
+        "rag_poems": st.session_state.rag,
+        "draft_poem": st.session_state.draft_poem,
+        "draft_poem_fb": st.session_state.reflexion,
+        "professor": st.session_state.professor,
+        "final_poem": st.session_state.poema,
+    }
+
+    # Almacenamos los poemas generados
+    if accion == "insert":
+        # Añadimos registro
+        data, count = st.session_state.supabase.table("Poemas").insert(data).execute()
+        # Recuperamos el id insertado
+        st.session_state.id = data[1][0]['id']
+
+    if accion == "update":
+        id = st.session_state.id
+        data, count = st.session_state.supabase.table("Poemas").update(data).eq("id", id).execute()
+
+
+
+# ----- Función para mostrar el resumen del poema generado ----------------------------------
+def resumen():
+
+    st.header(":memo: Metodología desarrollada", divider='gray')
+
+    # Muestro el tema y estilo proporcionados
+    col1, col2 = st.columns(2)
+    with col1:
+        input1 = st.text_input("Tema", value=st.session_state.tema, disabled=True)
+    with col2:    
+        input2 = st.text_input("Estilo", value=st.session_state.estilo, disabled=True)
+
+    # Separador
+    st.subheader('Contexto', divider='red', help="Se muestra el *contexto* generado que se incrustará en el _prompt_")
+
+    # Mostrar el conocimiento experto
+    with st.expander("Expertise Knowledge (HITL)", icon="👩‍💻"):
+        for item in st.session_state.expertise:
+            st.markdown(f"```\n{item}\n```")
+
+    # Imprimir la conocimiento generado
+    with st.expander("Conocimiento generado", icon="💻"):
+        for item in st.session_state.generated:
+            st.markdown(f"""<span>{item}</span>""", unsafe_allow_html=True)
+
+    # Imprimir la conocimiento recuperado
+    with st.expander("Conocimiento recuperado", icon="💾"):
+        for item in st.session_state.rag:
+            st.markdown(f"```\n{item}\n```")
+
+    # Separador
+    st.subheader('Reflexión', divider='red', help="Se muestra el borrador poético y las reflexiones de los expertos")
+
+    # Imprimir el borrador poético
+    with st.expander("Borrador poético", icon="📃"):
+        st.markdown(f"```\n{st.session_state.draft_poem}\n```")
+
+    # Imprimir la reflexión del catedrático
+    with st.expander("Reflexión del catedrático", icon="🎓"):
+        for item in st.session_state.reflexion:
+            st.markdown(f"""<span>{item}</span>""", unsafe_allow_html=True)
+
+    # Imprimir el poema
+    if "expert_poem" in st.session_state:
+        with st.expander("Poema revisado", icon="📃"):
+            st.markdown(f"```{st.session_state.expert_poem}```")
+
+    # Imprimir la reflexión del catedrático
+    if "professor" in st.session_state:
+        with st.expander("Reflexión del profesor (HITL)", icon="👩‍🎓"):
+            for item in st.session_state.professor:
+                st.markdown(f"""<span>{item}</span>""", unsafe_allow_html=True)
+
+    # Separador
+    st.subheader('Poema :scroll:', divider='rainbow', help="Se muestra el poema elaborado")
+
+    # Imprimir el poema
+    st.markdown(f"```\n{st.session_state.poema}\n```")
+
+
+
+#####################
+# Función principal #
+#####################
+def main():
+    st.set_page_config(page_title="Generador de poemas")
+    
+    if "draft_poem" not in st.session_state:
+        st.session_state.draft_poem = "No hay borrador poético."
+        #st.session_state.expert_poem = ""
+        st.session_state.poema = "No hay poema elaborado."
+    if "generated" not in st.session_state:
+        st.session_state.generated = ["No hay conocimiento generado."]
+    if "expertise" not in st.session_state:
+        st.session_state.expertise = ["No hay conocimiento experto proporcionado."]
+    if "rag" not in st.session_state:
+        st.session_state.rag = ["No hay conocimiento aumentado por recuperación."]
+    if "reflexion" not in st.session_state:
+        st.session_state.reflexion = ["No hay revisiones del catedrático."]
+    if "professor" not in st.session_state:
+        st.session_state.professor = ["No hay revisiones del profesor."]
+    if 'tema' not in st.session_state:
+        st.session_state.tema = ""
+    if 'estilo' not in st.session_state:
+        st.session_state.estilo = ""
+
+    # Ejecutamos la configuración
+    __init__()
+    
+    # Sidebar con los enlaces a los pasos
+    opciones = {
+        "Topic&Style": grafo,
+        "Metodología": resumen,
+        "Expertise (HITL)": expertise_knowledge,
+        "Professor (HITL)": professor_reflexion,
+        "Configuración": configuracion,        
+    }
+    #st.sidebar.title("Pasos")
+    #selected = st.sidebar.radio("Selecciona un paso", list(opciones.keys()))
+
+    # Enlace a la librería de menús: https://github.com/victoryhb/streamlit-option-menu
+    with st.sidebar:
+        seleccion = option_menu(None, list(opciones.keys()), 
+            icons=['envelope-paper-heart','envelope-heart','person-hearts','person-square', 'gear'], 
+            menu_icon="cast", 
+            default_index=0)
+        st.image("img/bot.webp", width=250)        
+
+    # Muestra el paso seleccionado
+    opciones[seleccion]()
+
+
+if __name__ == "__main__":
+
+    main()

requirements.txt

@@ -0,0 +1,10 @@
+langchain-community
+langchain_groq
+langchain_openai
+langchain_pinecone
+sentence_transformers
+streamlit
+langgraph
+supabase
+openai
+python-dotenv