From 9227a4201feb9b36cb7f26fb110b8199c4073125 Mon Sep 17 00:00:00 2001
From: mongar <cristian.montoya.g.com>
Date: Wed, 1 May 2024 12:44:57 -0500
Subject: [PATCH] Se integra a la apliacion un LLM open source de HuggingFace

---
 app.py                                        |   2 +-
 app_2.py                                      | 134 ++++++++++++++++++
 .../__pycache__/lc_tools.cpython-311.pyc      | Bin 7235 -> 8341 bytes
 langchain_tools/lc_tools.py                   |  96 +++++++++----
 pruebas_open_source.py                        | 128 +++++++++++++++++
 5 files changed, 329 insertions(+), 31 deletions(-)
 create mode 100644 app_2.py
 create mode 100644 pruebas_open_source.py

diff --git a/app.py b/app.py
index d1038f7..2bcfdf6 100644
--- a/app.py
+++ b/app.py
@@ -57,7 +57,7 @@ if pdf_name:
         )
 
     # Cargamos el modelo LLM desde LangChain
-    llm = langChainTools.load_llm_openai()
+    llm = langChainTools.load_llm_open_source()
 
     # Creamos la cadena que integra Vectorstroe, el LLM para hacer consultas.
     # Para este caso la cadena tene el parametro de memoria.
diff --git a/app_2.py b/app_2.py
new file mode 100644
index 0000000..efd42cf
--- /dev/null
+++ b/app_2.py
@@ -0,0 +1,134 @@
+# import os
+# from dotenv import load_dotenv
+# from langchain_community.chat_models import ChatOpenAI
+import streamlit as st
+from chats.streamlit_tools import import_file  # ,clear_cache
+from streamlit_extras.add_vertical_space import add_vertical_space
+from langchain_tools.pdf_tools import PdfLangChain
+from langchain_tools.lc_tools import LangChainTools
+from chats.chat_tools import MessageManager
+from langchain_community.llms import HuggingFaceEndpoint
+
+
+# App title
+st.set_page_config(page_title="LLMOneClusterTeam")
+
+# sidebar
+with st.sidebar:
+    # Cargar el logo (asegúrate de que el archivo de imagen esté en la misma carpeta que tu script)
+    logo_path = "documents/Logo azulblanco.png"
+    logo = st.sidebar.image(logo_path, width=200)
+
+    # Ajusta el ancho según sea necesario
+    add_vertical_space(28)
+    # pdf_name = import_file()
+    st.markdown("Built by [OneCluster](https://www.onecluster.org/).")
+
+
+col1, col2 = st.columns([1.1, 1])
+with col1:
+    st.title(
+        "DocumentAssist",
+    )
+with col2:
+    logo_2 = st.image("documents/pdfs/logo_1-removebg-preview.png", width=110)
+
+pdf_name = import_file()
+if pdf_name:
+    with st.spinner("Processing the document..."):
+        # Inicializamos la clase PdfLangChain
+        pdfLangChain = PdfLangChain(pdf_name)
+        pdf_name = pdfLangChain.file_name
+
+        # Cargamos el documento PDF
+        docs: list = pdfLangChain.load_pdf()
+
+        # Dividimos los documentos en partes mas pequenas
+        docs_split: list = pdfLangChain.split_docs(docs)
+
+        # Instanciamos la clase LangChainTools que contiene herramientras LangChain
+        langChainTools = LangChainTools()
+
+        # Cargamos el modelo de embeddings
+        embedding_model = langChainTools.load_embedding_opnai()
+
+        # Creamos el vector store
+        docstorage = langChainTools.create_vector_strore(
+            docs_split, pdf_name, embedding_model
+        )
+
+    # Cargamos el modelo LLM desde LangChain
+    llm = langChainTools.load_llm_open_source()
+
+    # Creamos la cadena que integra Vectorstroe, el LLM para hacer consultas.
+    # Para este caso la cadena tene el parametro de memoria.
+    qa = langChainTools.define_retrieval_qa_memory(
+        llm, docstorage, pdf_name, embedding_model
+    )
+
+    # Store conversation history
+    if "messages" not in st.session_state.keys():
+        st.session_state.messages = [
+            {
+                "role": "assistant",
+                "content": "Hola, soy una IA con el que puedes chatear con tu PDF. Haz un pregunta al documento.",
+            }
+        ]
+
+    # Display or clear chat messages
+    for message in st.session_state.messages:
+        with st.chat_message(message["role"]):
+            st.write(message["content"])
+
+    def clear_chat_history():
+        st.session_state.messages = [
+            {
+                "role": "assistant",
+                "content": "Hola, soy una IA con el que puedes chatear con tu PDF. Haz un pregunta al documento.",
+            }
+        ]
+
+    st.sidebar.button("Clear chat history", on_click=clear_chat_history)
+
+    @st.cache_resource
+    def get_num_tokens(prompt):
+        """Get the number of tokens in a given prompt"""
+        return len(prompt.split())
+
+    # Function for generating Snowflake Arctic response
+
+    # User-provided prompt
+    if prompt := st.chat_input():
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        with st.chat_message("user"):
+            st.write(prompt)
+
+        # Generate a new response if last message is not from assistant
+        if st.session_state.messages[-1]["role"] != "assistant":
+            with st.spinner("Thinking..."):
+                # Creamos la cadena que integra Vectorstroe, el LLM para hacer consultas.
+                # Para este caso la cadena tene el parametro de memoria.
+                qa = langChainTools.define_retrieval_qa_memory(
+                    llm, docstorage, pdf_name, embedding_model
+                )
+
+                input = "\n".join([msg["content"] for msg in st.session_state.messages])
+
+                query = qa.invoke({"question": f"{prompt}"}, return_only_outputs=True)
+
+                response_text_en = query["answer"]
+                documents_source = query["source_documents"]
+
+                messageManager = MessageManager()
+
+                citation: str = messageManager.generate_citations(documents_source)
+                # st.markdown(citation)
+
+            with st.chat_message("assistant"):
+                st.write(response_text_en)
+                # st.write(translation)
+                st.session_state.messages.append(
+                    {"role": "assistant", "content": response_text_en}
+                )
+                expander = st.expander("Fuentes")
+                expander.markdown(citation)
diff --git a/langchain_tools/__pycache__/lc_tools.cpython-311.pyc b/langchain_tools/__pycache__/lc_tools.cpython-311.pyc
index 0708cbddeb19856d228720672a778729b145c2a6..be078b147d4e1fa99de9251244c11456f454864c 100644
GIT binary patch
delta 2367
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

delta 1392
zcmai!|7#m%9LJx#<}P>FyClt$T#{aL>9>q*v1$6nPDwk5Zms?>1{IVsC~0%mO44M{
zWrKlZLnr13LCfPn5CswHqyr~`{UC_nepIna!81_kf8d3+zsLkXpVYKJxZwl$y61U6
zpL?G7=kq+t?K3}|@_nXh3V}AP<yXFst^1<f`|HQArFb$&O3E!#>fPW8*@WkyT@01H
z3nZhi|8!qp?uz&p{vAB1vwPe^+7ez9yVE847TJKoW>+8=wUPp>^fq(+pB&f6OwXHK
zxcRB)XPz5mm%Ujo$UgQyCC1<b8fQCR6Xd_WaW2B5(yTTDvfTvSByN!X7#e4{rJ+lT
zZ0_g@XK=z9ns5a^I@KnCJw#)^F~2X7XmVT6VnBSviJx%2J<)8N0QL}#c~>D?_;=O#
zO*MX1liO-?OHJ<j^@g8Dn;|*L2?5yh6*jG$0>?E)e=>;njv+ABjE9D?--nn4w3KqW
zvRJKIYsFRD140TKjj*qkN%1)t+Vkv=#~j^_#2URjVe`&uCp+!rW}K5buolUKwMZVU
zMe+>=tOep*QVg72*S_P1I~zTXd-!X#TB+3+>sF;!F4ir(=U^k)XURXyy~IB8n=!6`
zrcD5Qh=$)4Nx<BalCatz{`);C13sY%L=s^lQiuV-i*%fQacoIUqi~$*p<DrXZ+R9W
zyOz9o)mpAsX=#bZG2jWrC}I$U_{&9Gf(~Ym4P3nuDrm2QWPb#J15CpK&IKJa2WJ+B
zqycbd;XE4-pXrZ6%yRc;L7#Zx!3-Y^H*bc0T%xxm-BmXrV)HQSy7amPcT2nS4tp4Q
zySb#xeEjhlvbSPqZ=8d(I}NM0#EMm^(rfft7|>?`881CZ90fc>DkD@tOIm@_V-@IG
z7-nRe#i?_MIm9ChLNCBXOI@z6UA3rPtglwrY?)|B1;PsL_P-#$2XXdSY|J=6_21Go
z<b8z%PdNIBW27A2gzFL<fa?+*fa?+*Xo&kN`_f2oG4_iQ@sWVBCG}G*<@t<{X^Bxz
zXNAPj<QSTqM$90dM=St7C!Js#LBZFBA3FA3_CaFoh9N}ng<Jx!ZznphBeZ*nsBa4q
zmxo!m&?m%Qa)`8FFkNzp!L$%`$ssOqM3g$8o)iq10FD;xDjiupu!qhvVP+-2>BApl
zOSbFODpty?b^0=!GRKE5p><5VlgVFFp;9efDO<C21vCyG`yqSR{BYIf;a|rk{|}|Y
RbKvaJY<Kj%$INzo`~w#6H}C)e

diff --git a/langchain_tools/lc_tools.py b/langchain_tools/lc_tools.py
index 885107c..6027dc6 100644
--- a/langchain_tools/lc_tools.py
+++ b/langchain_tools/lc_tools.py
@@ -7,12 +7,11 @@ from langchain.memory.buffer import ConversationBufferMemory
 import os
 import streamlit as st
 from dotenv import load_dotenv
-from langchain.chains import (
-    RetrievalQAWithSourcesChain,
-    ConversationalRetrievalChain)
+from langchain.chains import RetrievalQAWithSourcesChain, ConversationalRetrievalChain
+from langchain_community.llms import HuggingFaceEndpoint
 
 
-class LangChainTools():
+class LangChainTools:
     """
     Esta clase maneja algunas herramientas integraciones con las que
     cuenta LangChain.
@@ -27,7 +26,7 @@ class LangChainTools():
 
         # Cargamos la variable que contiene la api_key de OpenAI
         load_dotenv()
-        openai_api_key = os.getenv('api_key')
+        openai_api_key = os.getenv("api_key")
         # Define an OpenAI embeddings model
         self.embedding_model = OpenAIEmbeddings(openai_api_key=openai_api_key)
         # st.success('El modelo de embeddins de OpneAI se ha cargado')
@@ -35,7 +34,9 @@ class LangChainTools():
         return self.embedding_model
 
     @st.cache_resource
-    def create_vector_strore(_self, _docs_split: list, _file_name: str, _embedding_model):
+    def create_vector_strore(
+        _self, _docs_split: list, _file_name: str, _embedding_model
+    ):
         """Esta funcion construye un vector store a partir de un documento
 
         Args:
@@ -43,7 +44,7 @@ class LangChainTools():
             _file_name (str): Nombre del documento
         """
 
-        db_name = _file_name.replace('.pdf', '').replace(' ', '_').lower()
+        db_name = _file_name.replace(".pdf", "").replace(" ", "_").lower()
 
         # Cargamos el modelo de embeddings
         # _embedding_model = self._embedding_model
@@ -53,13 +54,14 @@ class LangChainTools():
 
         if os.path.exists(persist_directory):
             vectordb = Chroma(
-                persist_directory=persist_directory,
-                embedding_function=_embedding_model)
+                persist_directory=persist_directory, embedding_function=_embedding_model
+            )
         else:
             vectordb = Chroma.from_documents(
                 persist_directory=persist_directory,
                 documents=_docs_split,
-                embedding=_embedding_model)
+                embedding=_embedding_model,
+            )
 
             vectordb.persist()
 
@@ -74,16 +76,44 @@ class LangChainTools():
 
         # Cargamos la variable que contiene la api_key de OpenAI
         load_dotenv()
-        openai_api_key = os.getenv('api_key')
+        openai_api_key = os.getenv("api_key")
 
         temperature = 0.5
-        llm_openai = ChatOpenAI(model_name="gpt-3.5-turbo",
-                                temperature=temperature,
-                                openai_api_key=openai_api_key,
-                                max_tokens=1000)
+        llm_openai = ChatOpenAI(
+            model_name="gpt-3.5-turbo",
+            temperature=temperature,
+            openai_api_key=openai_api_key,
+            max_tokens=1000,
+        )
 
         return llm_openai
 
+    def load_llm_open_source(self):
+        """Esta funcion carga un modelo de LLM OpenSource desde HuggingFace
+
+        Returns:
+            _type_: Retorno a un objetito de tipo LLM de OpenAI
+        """
+        # model_huggingface = "google/gemma-1.1-7b-it"  # Es buena y funciona en espanol
+        # model_huggingface = (
+        #    "google/gemma-1.1-2b-it"  # Es buena y funciona en espanol funciona rapido
+        # )
+        # model_huggingface = 'tiiuae/falcon-7b-instruct'
+        # model_huggingface = 'mistralai/Mistral-7B-Instruct-v0.2'
+        huggingfacehub_api_token = "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"
+
+        model_huggingface = "mistralai/Mixtral-8x7B-Instruct-v0.1"  # Es buena y funciona en espanol funciona rapido
+
+        # Define the LLM
+        llm = HuggingFaceEndpoint(
+            repo_id=model_huggingface,
+            huggingfacehub_api_token=huggingfacehub_api_token,
+            temperature=0.5,
+            max_new_tokens=500,
+        )
+
+        return llm
+
     def load_prompt_template(self):
         """Esta funcion construye un prompt template de lanfchain.
 
@@ -97,13 +127,12 @@ class LangChainTools():
         Respuesta:"""
 
         prompt_template = PromptTemplate(
-            template=template, input_variables=["question"])
+            template=template, input_variables=["question"]
+        )
 
         return prompt_template
 
-    def define_retrieval_qa(
-        self, _llm, _vectordb, _file_name, _embedding_model
-    ):
+    def define_retrieval_qa(self, _llm, _vectordb, _file_name, _embedding_model):
         """Esta función integra un LLM y una base de datos vectorial en una
         chain de LangChain para hacer requerimientos. Este modelo no integra memoria.
 
@@ -120,14 +149,14 @@ class LangChainTools():
             y la BDV.
         """
 
-        db_name = _file_name.replace('.pdf', '').replace(' ', '_').lower()
+        db_name = _file_name.replace(".pdf", "").replace(" ", "_").lower()
 
         # Verificamos si existe la vector strore
         persist_directory = f"embeddings/{db_name}"
 
         _vectordb = Chroma(
-            persist_directory=persist_directory,
-            embedding_function=_embedding_model)
+            persist_directory=persist_directory, embedding_function=_embedding_model
+        )
 
         # Define the Retrieval QA Chain to integrate the database and LLM
         qa = RetrievalQAWithSourcesChain.from_chain_type(
@@ -161,28 +190,35 @@ class LangChainTools():
             y la BDV.
         """
 
-        db_name = _file_name.replace('.pdf', '').replace(' ', '_').lower()
+        db_name = _file_name.replace(".pdf", "").replace(" ", "_").lower()
 
         # Verificamos si existe la vector strore
         persist_directory = f"embeddings/{db_name}"
 
         _vectordb = Chroma(
-            persist_directory=persist_directory,
-            embedding_function=_embedding_model)
+            persist_directory=persist_directory, embedding_function=_embedding_model
+        )
 
         # Configura la memoria
         memory = ConversationBufferMemory(
-            memory_key="chat_history",
-            return_messages=True,
-            output_key='answer')
+            memory_key="chat_history", return_messages=True, output_key="answer"
+        )
 
         # Define the Retrieval QA Chain to integrate the database and LLM
         conversation = ConversationalRetrievalChain.from_llm(
             _llm,
             retriever=_vectordb.as_retriever(),
             memory=memory,
-            verbose=False,  # Modo verboso
-            return_source_documents=True  # Devuelve los documentos fuente
+            verbose=True,  # Modo verboso
+            return_source_documents=True,  # Devuelve los documentos fuente
         )
 
+        template = """Utiliza los siguientes fragmentos de contexto para responder la pregunta al final. Si no sabes la respuesta, simplemente di que no sabes, no intentes inventar una respuesta. La respuesta dala con un formateo de markdown. Responde a la pregunta siempre en español.
+        
+        {context}
+
+        Pregunta: {question}
+        Respuesta:"""
+        conversation.combine_docs_chain.llm_chain.prompt.template = template
+
         return conversation
diff --git a/pruebas_open_source.py b/pruebas_open_source.py
new file mode 100644
index 0000000..ed40bd0
--- /dev/null
+++ b/pruebas_open_source.py
@@ -0,0 +1,128 @@
+from langchain_community.llms import HuggingFaceEndpoint
+from langchain.chains import LLMChain
+from langchain.memory import ConversationBufferMemory
+from langchain_core.prompts import PromptTemplate
+from langchain_openai import OpenAIEmbeddings
+
+
+# model_huggingface = 'google/gemma-1.1-7b-it' # Es buena y funciona en espanol
+
+# model_huggingface = 'tiiuae/falcon-7b-instruct'
+# model_huggingface = 'mistralai/Mistral-7B-Instruct-v0.2'
+# model_huggingface = "google/gemma-7b"
+# model_huggingface = (
+#    "mistralai/Mixtral-8x7B-Instruct-v0.1"  # Es muy buena y funciona en espanol
+# )
+
+huggingfacehub_api_token = "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"
+
+model_huggingface = (
+    "google/gemma-1.1-2b-it"  # Es buena y funciona en espanol funciona rapido
+)
+
+# Define the LLM
+llm = HuggingFaceEndpoint(
+    repo_id=model_huggingface,
+    huggingfacehub_api_token=huggingfacehub_api_token,
+    temperature=0.5,
+    max_new_tokens=500,
+)
+
+# for chunk in llm.stream("Como se construye un ensayo?"):
+#     print(chunk, end="", flush=True)
+
+# question = "Como se construye un ensayo?"
+# output = llm.invoke(question)
+
+# print(output)
+
+
+# prompt = PromptTemplate(
+#    input_variables=["chat_history", "human_input"], template=template
+# )
+# memory = ConversationBufferMemory(memory_key="chat_history")
+
+# llm = OpenAI()
+# llm_chain = LLMChain(
+#    llm=llm,
+#    prompt=promptas st
+from langchain_tools.pdf_tools import PdfLangChain
+from langchain_tools.lc_tools import LangChainTools
+from langchain_community.llms import HuggingFaceEndpoint
+from langchain.chains.question_answering import load_qa_chain
+from langchain.memory import ConversationBufferMemory
+from langchain_core.prompts import PromptTemplate
+
+# Inicializamos la clase PdfLangChain
+pdfLangChain = PdfLangChain("1.TC_Malamud, Se está muriendo la democracia.pdf")
+pdf_name = pdfLangChain.file_name
+
+# Cargamos el documento PDF
+docs: list = pdfLangChain.load_pdf()
+
+# Dividimos los documentos en partes mas pequenas
+docs_split: list = pdfLangChain.split_docs(docs)
+
+# Instanciamos la clase LangChainTools que contiene herramientras LangChain
+langChainTools = LangChainTools()
+
+# Cargamos el modelo de embeddings
+embedding_model = langChainTools.load_embedding_opnai()
+
+# Creamos el vector store
+docstorage = langChainTools.create_vector_strore(docs_split, pdf_name, embedding_model)
+
+
+template = """Tu eres un chatbot y tienes una conversacion con un humano quien te \
+hara preguntas y tu deberas responder con base al context y al chat_history. Si no \
+conocer la respuesta, solo repsonde que no sabes como responder.
+
+
+{context}
+
+{chat_history}
+Human: {question}
+Chatbot:"""
+
+prompt = PromptTemplate(
+    input_variables=["chat_history", "human_input", "context"], template=template
+)
+memory = ConversationBufferMemory(memory_key="chat_history", input_key="question")
+chain = load_qa_chain(
+    llm,
+    chain_type="stuff",
+    memory=memory,
+    prompt=prompt,
+    verbose=True,
+)
+
+query = "cuales son los elementos clave del texto?"
+# documents = docstorage.similarity_search(query)
+# respuesta = chain.invoke(
+#     {"question": f"{prompt}", "input_documents": documents}, return_only_outputs=False
+# )
+# chain({"input_documents": documents, "human_input": query}, return_only_outputs=True)
+# print(documents)
+# print(respuesta["output_text"])
+
+
+from langchain.chains import RetrievalQAWithSourcesChain, ConversationalRetrievalChain
+
+chain = ConversationalRetrievalChain.from_llm(llm, docstorage.as_retriever())
+
+print(dir(chain))
+
+print(chain)
+
+# template = f"Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.\n\n{context}\n\nQuestion: {question}\nHelpful Answer:"
+
+template = "Utiliza los siguientes fragmentos de contexto para responder la pregunta al final. Si no sabes la respuesta, simplemente di que no sabes, no intentes inventar una respuesta.\n\n{context}\n\nQuestion: {question}\nRespuesta útil:"
+
+# Define el nuevo template que deseas utilizar
+new_template = "Este es un nuevo template que reemplazará al anterior.\n\n{context}\n\nPregunta: {question}\nRespuesta útil:"
+
+# Accede al prompt del LLMChain en combine_docs_chain y actualiza su template
+chain.combine_docs_chain.llm_chain.prompt.template = template
+print("\n\n")
+# Imprime la instancia de clase para verificar que se haya actualizado el template
+print(chain)