Primera subida ficheros de la app

app.py

@@ -0,0 +1,254 @@
+
+##Instalación de paquetes necesarios
+import streamlit as st
+import os
+import time
+import torch
+from utils import *
+from dotenv import load_dotenv
+load_dotenv()
+
+##import nest_asyncio
+##nest_asyncio.apply()
+from llama_parse import LlamaParse
+
+from llama_index.llms.openai import OpenAI
+from llama_index.embeddings.openai import OpenAIEmbedding
+from llama_index.core import VectorStoreIndex, ServiceContext
+from llama_index.core import SimpleDirectoryReader
+from llama_index.core import Settings
+print(torch.cuda.is_available())
+######   
+
+## titulos y cabeceras 
+st.set_page_config('compare PDF por LLM')
+st.title("Comparar PDFs mediante LLM")
+st.subheader("Campos a comparar en tu PDF",divider='rainbow')
+
+####  Inicializar mensajes de chat 
+if "messages" not in st.session_state.keys():
+    st.session_state.messages = [
+        {"role": "assistant", "content": "Ask me a question about PDFs files you provided me"}
+    ]
+
+@st.cache_resource(show_spinner=False) # Añade decorador de caché
+def cargar_embedmodel_y_llmmodel():
+    return True
+    
+#esta variable es para tener aqui un listado de aquellos ficheros que se han ido subiendo
+archivos = [] 
+
+## carga y almacenamiento de ficheros almacenada, acepta varios.
+with st.sidebar:
+    archivos = load_name_files(FILE_LIST)
+    files_uploaded = st.file_uploader(
+        "Carga tus ficheros PDF",
+        type="pdf",
+        accept_multiple_files=True,
+        on_change=st.cache_resource.clear
+        )  
+
+    if st.button("Guardar y procesar por LLM", type="secondary",help="donde buscará lo que comparará"):
+        for pdf in files_uploaded:
+            if pdf is not None and pdf.name not in archivos:
+                archivos.append(pdf.name)
+             
+        archivos = save_name_files(FILE_LIST, archivos)
+    
+
+    if len(archivos)>0:
+        st.write('Los archivos PDF se han cargados:')
+        lista_documentos = st.empty()
+        with lista_documentos.container():
+            for arch in archivos:
+                st.write(arch)
+            if st.button('Borrar ficheros'):
+                archivos = []
+                clean_files(FILE_LIST)
+                lista_documentos.empty()
+
+
+# comprueba que hay archivos a ser tratados
+if len(archivos)>0:
+# comprueba que hay consulta a responder   
+   if user_question := st.chat_input("Realizar consulta:"): 
+      st.session_state.messages.append({"role": "user", "content": user_question})
+
+   if user_question: 
+        for message in st.session_state.messages: # Muestra anteriores mensajes
+            with st.chat_message(message["role"]):
+              st.write(message["content"])
+
+        alert = st.warning("Sea paciente") # Mensaje de aviso o warning al usuario
+        time.sleep(3) # establece tiempo espera en 3 segundos
+        alert.empty() # borra el aviso 
+
+# se define el analizador-parser de los documentos.
+        parser = LlamaParse(
+        api_key=os.environ["LLAMA_CLOUD_API_KEY"],    ##API de acceso a Cloud de LlamaIndex
+        result_type="markdown",                       # se toma "markdown", tambien hay text disponible 
+        verbose=True,
+        )
+
+        cargar_embedmodel_y_llmmodel()
+
+#se parametrizan los modelos de embedding y LLM        
+        embed_model=OpenAIEmbedding(model="text-embedding-3-small")   #embeddings para base de conocimiento
+        llm = OpenAI(model="gpt-3.5-turbo-0125")                      #modelo LLM usado
+
+        Settings.llm = llm
+        Settings.embed_model = embed_model
+
+        
+        tratar = load_name_files(FILE_LIST) ##variable que tomará los ficheros a tratar recuperados de funcion
+#        st.write(tratar[0]) # se puede desasteriscar en desarrollo para apoyo
+#        st.write(tratar[1]) # se puede desasteriscar en desarrollo para apoyo    
+        
+
+# Carga de los ficheros mediante LlamaParse, se ejecutará job para cada analizador-parser de los mismos        
+        docs_202401 = parser.load_data( f'{tratar[0]}')     
+        docs_202402 = parser.load_data( f'{tratar[1]}')
+        
+#uso de MarkdownElementNodeParser para analizar la salida de LlamaParse mediante un motor de consultas de recuperación(recursivo)
+        from llama_index.core.node_parser import MarkdownElementNodeParser
+        node_parser = MarkdownElementNodeParser(llm=OpenAI(model="gpt-3.5-turbo-0125"), num_workers=8)  
+
+        import pickle
+        from llama_index.postprocessor.flag_embedding_reranker import FlagEmbeddingReranker
+# se parametriza el modelo reranker
+        reranker = FlagEmbeddingReranker(
+            top_n=5,
+            model="BAAI/bge-reranker-large",
+        )
+#funcion para Facilitar el motor de consultas sobre el almacén de vectores, y poderse realizar la recuperación.
+        def create_query_engine_over_doc(docs, nodes_save_path=None):
+            """Big function to go from document path -> recursive retriever."""
+            if nodes_save_path is not None and os.path.exists(nodes_save_path):
+                raw_nodes = pickle.load(open(nodes_save_path, "rb"))
+            else:
+                raw_nodes = node_parser.get_nodes_from_documents(docs)
+                if nodes_save_path is not None:
+                    pickle.dump(raw_nodes, open(nodes_save_path, "wb"))
+
+            base_nodes, objects = node_parser.get_nodes_and_objects(
+                raw_nodes
+            )
+
+### Recuperador-retriever
+            # indice y motor 
+            vector_index = VectorStoreIndex(nodes=base_nodes+objects)
+            query_engine = vector_index.as_query_engine(
+                similarity_top_k=15,
+                node_postprocessors=[reranker]
+            )
+            return query_engine, base_nodes, vector_index   ###devuelve motor de consultas y nodos
+        
+## motores de consulta y nodos para cada documento usando la función anterior.
+## En los ficheros .pkl se puede ver la estructura de los documentos que ha conformado o analizado y será con la que trabajará.
+        query_engine_202401, nodes_202401,vindex1 = create_query_engine_over_doc(
+        docs_202401, nodes_save_path="202401_nodes.pkl"
+        )
+        query_engine_202402, nodes_202402,vindex2 = create_query_engine_over_doc(
+        docs_202402, nodes_save_path="202402_nodes.pkl"
+        )
+
+        from llama_index.core.tools import QueryEngineTool, ToolMetadata
+        from llama_index.core.query_engine import SubQuestionQueryEngine
+
+        from llama_index.core.llms import ChatMessage
+
+# motor de consulta como tool, configuración y contexto de los datos que deberá proveer por los que será consultado
+# debajo se usa como motor de subconsultas SubQuestionQueryEngine
+        query_engine_tools = [
+            QueryEngineTool(
+                query_engine=query_engine_202401,
+                metadata=ToolMetadata(
+                    name="pdf_ENERO",
+                    description=(
+#                        "Provides information about Datos del Producto for ENERO"
+#                        "Provides information about values of fields of Datos del Producto, Titular, Fabricante,Composicion,Envases, Usos y Dosis Autorizados,Plazos de Seguridad"
+                                                  """\
+                            The documents provided are plant protection product data sheets in PDF format.
+                            Provides information about values of fields of Datos del Producto, Titular, Fabricante,Composicion,Envases, 
+                            Usos y Dosis Autorizados,Plazos de Seguridad:
+                            # Datos del Producto
+                            |Numero de Registro|
+                            |Estado|
+                            |Fechas Inscripción|
+                            |Renovación|
+                            |Caducidad|
+                            |Nombre Comercial|
+
+                            # Titular
+
+                            # Fabricante
+
+                            # Composición
+
+                            # Envases
+
+                            # Usos y Dosis Autorizados
+                            |USO|
+                            |AGENTE|
+                            |Dosis|
+                            |Condic. Especifico|
+
+                            """
+                    ),
+                ),
+            ),
+            QueryEngineTool(
+                query_engine=query_engine_202402,
+                metadata=ToolMetadata(
+                    name="pdf_FEBRERO",
+                    description=(
+#                        "Provides information about Datos del Producto for FEBRERO"
+#                        "Provides information about values of fields of Datos del Producto, Titular, Fabricante,Composicion,Envases, Usos y Dosis Autorizados,Plazos de Seguridad"
+                         """\
+                            The documents provided are plant protection product data sheets in PDF format.
+                            Provides information about values of fields of Datos del Producto, Titular, Fabricante,Composicion,Envases, 
+                            Usos y Dosis Autorizados,Plazos de Seguridad:
+                            # Datos del Producto
+                            |Numero de Registro|
+                            |Estado|
+                            |Fechas Inscripción|
+                            |Renovación|
+                            |Caducidad|
+                            |Nombre Comercial|
+
+                            # Titular
+
+                            # Fabricante
+
+                            # Composición
+
+                            # Envases
+
+                            # Usos y Dosis Autorizados
+                            |USO|
+                            |AGENTE|
+                            |Dosis|
+                            |Condic. Especifico|
+
+                            """
+                    ),
+                ),
+            ),
+        ]
+# subconsultas con tool creada a través de SubQuestionQueryEngine
+        sub_query_engine = SubQuestionQueryEngine.from_defaults(
+            query_engine_tools=query_engine_tools,
+            llm=llm
+        )
+
+        if "chat_engine" not in st.session_state.keys(): # Initializa motor chat
+# para que generen las subconsultas con la consulta-query del usuario           
+            streaming_response = sub_query_engine.query(user_question)
+        
+##      If last message is not from assistant, generate a new response
+        if st.session_state.messages[-1]["role"] != "assistant":
+            with st.chat_message("assistant"):
+                with st.spinner("Thinking..."):    #figura del spinner de streamlit mientras se ejecuta bloque
+                     response = st.write(streaming_response.response)  #respuesta entregada a la query-consulta del usuario
+                     st.session_state.messages.append({"role": "assistant", "content": response})
+        

ficheros.txt

@@ -0,0 +1 @@
+

requirements.txt

@@ -0,0 +1,8 @@
+llama-index
+llama-index-embeddings-openai
+llama-index-core
+llama-index-llms-openai
+llama-index-question-gen-openai
+llama-index-postprocessor-flag-embedding-reranker
+git+https://github.com/FlagOpen/FlagEmbedding.git
+llama-parse

utils.py

@@ -0,0 +1,35 @@
+import os
+#import streamlit as st
+import tempfile
+
+#donde se almacenan los ficheros subidos por usuario
+FILE_LIST = "ficheros.txt"
+
+#funcion para cargar ficheros 
+def load_name_files(path):
+
+    archivos = []
+    with open(path, "r") as file:
+        for line in file:
+            archivos.append(line.strip())
+
+    return archivos
+
+#informa nombres de ficheros a ser almacenados
+def save_name_files(path, new_files):
+
+    old_files = load_name_files(path)
+
+    with open(path, "a") as file:
+        for item in new_files:
+            if item not in old_files:
+                file.write(item + "\n")
+                old_files.append(item)
+    
+    return old_files
+
+#limpieza de los ficheros
+def clean_files(path):
+    with open(path, "w") as file:
+        pass
+    return True