RAG con prompting

.gitignore

@@ -0,0 +1 @@
+.env

app.py

@@ -2,185 +2,153 @@ import os
 import streamlit as st
 from dotenv import load_dotenv
 
-# Lectura y procesamiento de PDFs
+# Lector de PDFs
 from PyPDF2 import PdfReader
+
+# Fragmentador de texto
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 
-# Embeddings y VectorStores
+# Embeddings y VectorStore
 from langchain_community.embeddings.spacy_embeddings import SpacyEmbeddings
 from langchain_community.vectorstores import FAISS
 
-# LLM y Herramientas
-from langchain_openai import ChatOpenAI
-from langchain_core.prompts import ChatPromptTemplate
-from langchain.tools.retriever import create_retriever_tool
-from langchain.agents import AgentExecutor, create_tool_calling_agent
+# Librerías de LangChain para RAG
+from langchain.chains import ConversationalRetrievalChain
+from langchain.chat_models import ChatOpenAI
+from langchain.memory import ConversationBufferMemory
+from mi_prompt import tu_prompt_personalizado
+
 
-# Cargar variables de entorno
+# Cargar .env si lo necesitas
 load_dotenv()
-os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"  # A veces necesario en Windows o entornos concretos
 
-# Inicializamos el embedding con spaCy
+# Ajuste puntual (opcional en ciertos entornos Windows)
+os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
+
+# Embeddings con spaCy (puedes cambiarlo por OpenAIEmbeddings, etc.)
 embeddings = SpacyEmbeddings(model_name="en_core_web_sm")
 
-# -----------------------------------------------------------
+# ---------------------------------------------
 # Funciones auxiliares
-# -----------------------------------------------------------
-def pdf_read(pdf_docs):
-    """
-    Lee cada PDF y concatena su texto.
-    """
+# ---------------------------------------------
+def read_pdfs(pdf_files):
+    """Lee cada PDF y concatena su texto."""
     text = ""
-    for pdf in pdf_docs:
-        pdf_reader = PdfReader(pdf)
+    for pdf_file in pdf_files:
+        pdf_reader = PdfReader(pdf_file)
         for page in pdf_reader.pages:
             text += page.extract_text() or ""
     return text
 
-def get_chunks(text):
-    """
-    Divide el texto en chunks para indexarlo en FAISS.
-    """
+def chunk_text(text):
+    """Divide el texto en chunks."""
     text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
-    return text_splitter.split_text(text)
-
-def create_vector_store(text_chunks):
-    """
-    Crea un FAISS VectorStore a partir de los chunks.
-    """
-    vector_store = FAISS.from_texts(text_chunks, embedding=embeddings)
-    return vector_store
-
-def get_conversational_chain(tool, question):
-    """
-    Genera la respuesta a la pregunta usando la herramienta de recuperación.
-    """
-    api_key = os.getenv("OPENAI_API_KEY")
-
-    # Modelo LLM (adaptar model_name según lo que tengas disponible)
-    llm = ChatOpenAI(
-        model_name="gpt-4o-mini",  # O "gpt-3.5-turbo", etc.
-        temperature=0.4,
-        api_key=api_key
-    )
-
-    # Plantilla de prompt
-    prompt = ChatPromptTemplate.from_messages([
-        (
-            "system",
-            """Eres un asistente útil. Responde la pregunta de la forma más completa posible 
-            utilizando solo el contexto disponible. Si la respuesta no está en el contexto, 
-            di: "answer is not available in the context"."""
-        ),
-        ("placeholder", "{chat_history}"),
-        ("human", "{input}"),
-        ("placeholder", "{agent_scratchpad}"),
-    ])
-
-    # Creamos el agente con la herramienta y ejecutamos
-    agent = create_tool_calling_agent(llm, tools=[tool], prompt=prompt)
-    agent_executor = AgentExecutor(agent=agent, tools=[tool], verbose=False)
-    response = agent_executor.invoke({"input": question})
-    return response["output"]
-
-def generate_answer(user_question):
-    """
-    Usa la base vectorial en session_state y retorna la respuesta.
-    """
-    # Verifica si tenemos FAISS cargado
-    if "faiss_db" not in st.session_state or st.session_state["faiss_db"] is None:
-        return "No hay PDF(s) procesado(s). Por favor, carga y procesa algún PDF."
-
-    # Crea la herramienta de recuperación
-    db = st.session_state["faiss_db"]
-    retriever = db.as_retriever()
-    retrieval_tool = create_retriever_tool(
-        retriever, 
-        name="pdf_extractor",
-        description="This tool gives answers to queries from the PDF(s)."
-    )
-
-    # Obtiene la respuesta final usando la cadena conversacional
-    answer = get_conversational_chain(retrieval_tool, user_question)
-    return answer
-
-# -----------------------------------------------------------
+    chunks = text_splitter.split_text(text)
+    return chunks
+
+def create_vectorstore(chunks):
+    """Crea el FAISS VectorStore a partir de la lista de chunks."""
+    vectorstore = FAISS.from_texts(chunks, embedding=embeddings)
+    return vectorstore
+
+# ---------------------------------------------
 # Aplicación principal
-# -----------------------------------------------------------
+# ---------------------------------------------
 def main():
-    st.set_page_config(page_title="Chat PDF", layout="wide")
-    st.header("RAG-based Chat con PDF")
+    st.set_page_config(page_title="Chat PDF (RAG)", layout="wide")
+    st.header("RAG-based Chat con PDFs")
+
+    # Iniciamos el estado de la conversación en la app
+    if "conversation_chain" not in st.session_state:
+        st.session_state["conversation_chain"] = None
 
-    # Inicializa el historial de mensajes en session_state si no existe
+    # Guardamos el historial en session_state (para la UI)
     if "messages" not in st.session_state:
         st.session_state["messages"] = []
 
-    # Inicializa la base vectorial (None si aún no se ha creado)
-    if "faiss_db" not in st.session_state:
-        st.session_state["faiss_db"] = None
-
-    # ----------------------------------------------------------------
-    # SIDEBAR: subir y procesar PDFs
-    # ----------------------------------------------------------------
+    # Barra lateral: subir PDFs y procesarlos
     with st.sidebar:
         st.title("Menú:")
-        pdf_docs = st.file_uploader(
-            "Sube tus archivos PDF y haz clic en 'Procesar PDFs'.",
+        uploaded_pdfs = st.file_uploader(
+            "Sube tus PDFs y haz clic en 'Procesar PDFs'.",
             accept_multiple_files=True
         )
 
         if st.button("Procesar PDFs"):
-            if pdf_docs:
-                with st.spinner("Procesando..."):
-                    # Leemos y fragmentamos los PDFs en chunks
-                    raw_text = pdf_read(pdf_docs)
-                    text_chunks = get_chunks(raw_text)
-                    # Creamos la base vectorial FAISS y la guardamos en session_state
-                    new_vector_store = create_vector_store(text_chunks)
-                    st.session_state["faiss_db"] = new_vector_store
-                st.success("¡Hecho! Se han indexado los PDF.")
+            if uploaded_pdfs:
+                with st.spinner("Procesando e indexando..."):
+                    # 1) Leer PDFs
+                    raw_text = read_pdfs(uploaded_pdfs)
+
+                    # 2) Fragmentar texto
+                    text_chunks = chunk_text(raw_text)
+
+                    # 3) Crear FAISS VectorStore
+                    vectorstore = create_vectorstore(text_chunks)
+
+                    # 4) Crear la cadena conversacional con retrieval
+                    #    - ConversationalRetrievalChain maneja preguntas + contexto
+                    llm = ChatOpenAI(
+                        model_name="gpt-4o-mini",  # o "gpt-4", según tu acceso
+                        temperature=0
+                    )
+
+                    # Memoria para la conversación
+                    memory = ConversationBufferMemory(
+                        memory_key="chat_history", 
+                        return_messages=True
+                    )
+
+                    # Creamos la cadena RAG:
+                    conversation_chain = ConversationalRetrievalChain.from_llm(
+                        llm=llm,
+                        retriever=vectorstore.as_retriever(search_kwargs={"k": 6}),
+                        memory=memory,
+                        # Opcionalmente, ajusta cómo combinar la pregunta con los documentos:
+                        combine_docs_chain_kwargs={"prompt": tu_prompt_personalizado},
+                    )
+
+                    # Guardamos la cadena en session_state
+                    st.session_state["conversation_chain"] = conversation_chain
+                st.success("¡PDFs procesados y VectorStore creado!")
             else:
-                st.warning("No has seleccionado ningún PDF.")
+                st.warning("No subiste ningún PDF")
 
-        # Opción para borrar la base vectorial y subir otros PDFs
-        if st.button("Borrar vector store"):
-            st.session_state["faiss_db"] = None
-            st.info("Vector store borrado. Ahora puedes subir nuevos PDFs.")
+        # Botón para reiniciar
+        if st.button("Reiniciar VectorStore"):
+            st.session_state["conversation_chain"] = None
+            st.session_state["messages"] = []
+            st.info("Base vectorial reiniciada. Sube nuevos PDFs si lo deseas.")
 
-    # ----------------------------------------------------------------
-    # MAIN CHAT
-    # ----------------------------------------------------------------
-    st.subheader("Chat")
+    st.subheader("Chat con tus PDFs")
 
-    # Muestra los mensajes previos del historial
+    # Mostrar historial previo
     for msg in st.session_state["messages"]:
-        # Si quieres un formato sencillo:
         st.write(f"**{msg['role'].capitalize()}:** {msg['content']}")
-        
-        # O bien, podrías usar el componente experimental de chat si tu versión de Streamlit lo soporta:
-        # if msg["role"] == "user":
-        #     with st.chat_message("user"):
-        #         st.write(msg["content"])
-        # else:
-        #     with st.chat_message("assistant"):
-        #         st.write(msg["content"])
-
-    # Input de chat del usuario
-    user_input = st.text_input("Escribe tu pregunta aquí...")
+
+    # Input del usuario
+    user_input = st.text_input("Haz una pregunta sobre el/los PDF(s)...")
 
     if user_input:
-        # Guarda el mensaje del usuario
-        st.session_state["messages"].append({"role": "user", "content": user_input})
-        
-        # Genera la respuesta
-        answer = generate_answer(user_input)
-        
-        # Guarda la respuesta en el historial
-        st.session_state["messages"].append({"role": "assistant", "content": answer})
-        
-        # Para forzar el refresco (opcional en Streamlit 1.x). 
-        # Puedes comentarlo si te da problemas o no lo necesitas.
-        #st.experimental_rerun()
+        if st.session_state["conversation_chain"] is None:
+            st.warning("No hay PDFs procesados. Sube y procesa al menos un PDF.")
+        else:
+            # Guardamos mensaje del usuario en el historial
+            st.session_state["messages"].append({"role": "user", "content": user_input})
+
+            # Usar la cadena conversacional para obtener respuesta
+            response = st.session_state["conversation_chain"]({
+                "question": user_input
+            })
+
+            # El output viene en la llave "answer" por defecto con ConversationalRetrievalChain
+            answer = response["answer"]
+
+            # Añadir respuesta al historial
+            st.session_state["messages"].append({"role": "assistant", "content": answer})
+
+            # Mostrar la respuesta
+            st.write(f"**Asistente:** {answer}")
 
 if __name__ == "__main__":
     main()

mi_prompt.py

@@ -0,0 +1,21 @@
+from langchain.prompts import PromptTemplate
+
+tu_prompt_personalizado = PromptTemplate(
+    input_variables=["context", "question"],
+    template="""
+Eres un científico reconocido a nivel mundial en la materia contenida en los PDFs subidos.
+Responde a la pregunta de la forma más clara y detallada posible, basándote EXCLUSIVAMENTE 
+en la información provista en el siguiente "Contexto". 
+
+Indica, cuando sea posible, las referencias o fragmentos relevantes del contexto que te llevaron a 
+tu respuesta (pero evita copiar fragmentos muy largos). Si no encuentras la respuesta en el contexto, 
+di que no dispones de datos suficientes, o que puedes dar una guia mas clara de como encontrar esta información. 
+
+Contexto:
+{context}
+
+Pregunta: {question}
+
+Respuesta:
+""",
+)