Update app.py

app.py

@@ -1,106 +1,160 @@
-import openai
+import os
+import inspect
 import chainlit as cl
 import PyPDF2
-import numpy as np
-from sentence_transformers import SentenceTransformer
 
-# Configuración de la API DeepSeek
-DEEPSEEK_API_KEY = "TU_API_KEY_DEEPSEEK"
-openai.api_base = "https://api.deepseek.com/v1"
-openai.api_key = DEEPSEEK_API_KEY
-MODEL_NAME = "deepseek-chat"  # Modelo de DeepSeek a usar
+from langchain.embeddings.openai import OpenAIEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.vectorstores import Chroma
+from langchain.chains import RetrievalQAWithSourcesChain
+from langchain.chat_models import ChatOpenAI
+from langchain.prompts.chat import (
+    ChatPromptTemplate,
+    SystemMessagePromptTemplate,
+    HumanMessagePromptTemplate,
+)
 
-# Funciones auxiliares: leer PDFs y fragmentar texto
-def split_text(text, max_words=200):
-    words = text.split()
-    chunks = []
-    current_chunk = []
-    for word in words:
-        current_chunk.append(word)
-        if len(current_chunk) >= max_words:
-            chunks.append(" ".join(current_chunk))
-            current_chunk = []
-    if current_chunk:
-        chunks.append(" ".join(current_chunk))
-    return chunks
+# Clase personalizada que cumple con la nueva interfaz de EmbeddingFunction de Chroma
+class CustomOpenAIEmbeddings(OpenAIEmbeddings):
+    def __call__(self, input):
+        # Llama al método embed_documents para generar las embeddings a partir de una lista de textos
+        return self.embed_documents(input)
 
-def load_pdfs(pdf_paths):
-    doc_chunks = []
-    for path in pdf_paths:
-        try:
-            reader = PyPDF2.PdfReader(path)
-        except Exception as e:
-            print(f"Error al leer {path}: {e}")
-            continue
-        doc_name = path.split("/")[-1].replace(".pdf", "")
-        full_text = ""
-        for page in reader.pages:
-            text = page.extract_text() or ""
-            text = text.replace("\n", " ")
-            full_text += " " + text
-        for chunk in split_text(full_text, max_words=200):
-            doc_chunks.append({"doc": doc_name, "text": chunk})
-    return doc_chunks
+# Forzamos la firma de __call__ para que tenga exactamente ("self", "input")
+CustomOpenAIEmbeddings.__call__.__signature__ = inspect.Signature(
+    parameters=[
+        inspect.Parameter("self", inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        inspect.Parameter("input", inspect.Parameter.POSITIONAL_OR_KEYWORD)
+    ]
+)
+
+# --- CONFIGURACIÓN ---
+# Obtenemos la API key de OpenAI desde las variables de entorno
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+if not OPENAI_API_KEY:
+    raise ValueError(
+        "No se encontró la variable de entorno 'OPENAI_API_KEY'. Defínela en tu entorno o en los secrets."
+    )
 
-# Carga de documentos (especificar las rutas de los PDFs a usar)
-pdf_files = ['Managing Conflict with Your Boss .pdf', 'gestios de conflictos.pdf']  # etc.
-documents = load_pdfs(pdf_files)
+# Configuración del text splitter (modo in-memory, sin persistencia)
+text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
 
-# Preparar modelo de embeddings e indexar los fragmentos
-embedder = SentenceTransformer("sentence-transformers/distiluse-base-multilingual-cased-v2")
-def index_documents(doc_chunks):
-    texts = [entry["text"] for entry in doc_chunks]
-    embeddings = embedder.encode(texts, convert_to_numpy=True)
-    norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
-    embeddings_norm = embeddings / norms
-    return embeddings_norm
+# Plantilla del sistema para el prompt (en español)
+system_template = """Utiliza las siguientes piezas de contexto para responder la pregunta del usuario de manera breve y concisa.
+Si no sabes la respuesta, simplemente di que no lo sabes, no intentes inventarla.
+SIEMPRE incluye una parte "FUENTES" en tu respuesta, donde se indique el documento del cual obtuviste la información.
 
-doc_embeddings = index_documents(documents)
+Ejemplo:
+La respuesta es foo
+FUENTES: xyz
 
-# Función de búsqueda de fragmentos relevantes
-def retrieve_relevant(query, doc_chunks, doc_embeddings, top_k=3):
-    query_vec = embedder.encode(query, convert_to_numpy=True)
-    query_vec = query_vec / np.linalg.norm(query_vec)
-    sims = np.dot(doc_embeddings, query_vec)
-    top_idx = np.argsort(sims)[::-1][:top_k]
-    top_chunks = [doc_chunks[i] for i in top_idx]
-    return top_chunks
+----------------
+{summaries}"""
 
-# Función de generación de respuesta con DeepSeek
-def generate_answer(question, relevant_chunks):
-    # Armar texto de contexto con etiquetas de documento
-    context_text = ""
-    for chunk in relevant_chunks:
-        context_text += f"[{chunk['doc']}] {chunk['text']}\n"
-    system_message = {
-        "role": "system",
-        "content": (
-            "Eres un asistente experto que responde de forma profunda y analítica. "
-            "Tienes acceso a información de varios documentos proporcionados. "
-            "Usa el contenido dado como contexto, pero no te limites a copiarlo: "
-            "responde de forma argumentada, sintetizando la información y aportando visión crítica."
-        )
-    }
-    user_message = {
-        "role": "user",
-        "content": f"Contexto:\n{context_text}\nPregunta: {question}"
-    }
-    response = openai.ChatCompletion.create(
-        model=MODEL_NAME,
-        messages=[system_message, user_message],
-        temperature=0.7
-    )
-    answer = response["choices"][0]["message"]["content"]
-    return answer
+messages = [
+    SystemMessagePromptTemplate.from_template(system_template),
+    HumanMessagePromptTemplate.from_template("{question}")
+]
+prompt = ChatPromptTemplate.from_messages(messages)
+chain_type_kwargs = {"prompt": prompt}
 
-# Integración con Chainlit
+# --- EVENTO AL INICIAR EL CHAT ---
 @cl.on_chat_start
 async def on_chat_start():
-    await cl.Message(content="🤖 Asistente listo. Puede preguntarme sobre los documentos.").send()
+    await cl.Message(content="Bienvenido a la gestion de conflictos espero les agrade William , German , Carlos ").send()
+    
+    # Rutas de los PDFs (asegúrate de que estén en el directorio actual o ajusta las rutas)
+    pdf_paths = [
+        "gestios de conflictos.pdf",
+        "Managing Conflict with Your Boss .pdf"
+    ]
+    
+    all_texts = []
+    all_metadatas = []
+    
+    # Procesar cada PDF: extraer texto, dividirlo en fragmentos y asignar metadata
+    for path in pdf_paths:
+        base_name = os.path.basename(path)
+        with open(path, "rb") as f:
+            reader = PyPDF2.PdfReader(f)
+            pdf_text = ""
+            for page in reader.pages:
+                text = page.extract_text()
+                if text:
+                    pdf_text += text
+        chunks = text_splitter.split_text(pdf_text)
+        all_texts.extend(chunks)
+        all_metadatas.extend([{"source": base_name} for _ in chunks])
+    
+    # Crear la base vectorial usando nuestra clase personalizada de embeddings
+    # Al no especificar persist_directory se utiliza el modo in-memory, evitando la necesidad de configurar un tenant
+    embeddings = CustomOpenAIEmbeddings(openai_api_key=OPENAI_API_KEY)
+    docsearch = await cl.make_async(Chroma.from_texts)(
+    all_texts,
+    embeddings,
+    metadatas=all_metadatas,
+    persist_directory="./chroma_db"  # Directorio de persistencia
+)
+    
+    # Crear la cadena de QA utilizando ChatOpenAI
+    chain = RetrievalQAWithSourcesChain.from_chain_type(
+        ChatOpenAI(temperature=0, openai_api_key=OPENAI_API_KEY, max_tokens=400),
+        chain_type="stuff",
+        retriever=docsearch.as_retriever(),
+        chain_type_kwargs=chain_type_kwargs
+    )
+    
+    # Guardar en la sesión de usuario
+    cl.user_session.set("chain", chain)
+    cl.user_session.set("metadatas", all_metadatas)
+    cl.user_session.set("texts", all_texts)
+    
+    await cl.Message(content="¡Listo! Ya puedes hacer tus preguntas de manera breve.").send()
 
+# --- EVENTO AL RECIBIR UN MENSAJE DEL USUARIO ---
 @cl.on_message
-async def on_message(message: cl.Message):
-    query = message.content.strip()
-    top_chunks = retrieve_relevant(query, documents, doc_embeddings, top_k=3)
-    answer = generate_answer(query, top_chunks)
-    await cl.Message(content=answer).send()
+async def main(message: cl.Message):
+    query = message.content
+    chain = cl.user_session.get("chain")
+    cb = cl.AsyncLangchainCallbackHandler(
+        stream_final_answer=True,
+        answer_prefix_tokens=["FINAL", "ANSWER"]
+    )
+    cb.answer_reached = True
+    
+    res = await chain.acall(query, callbacks=[cb])
+    
+    answer = res["answer"]
+    sources = res["sources"].strip()
+    source_elements = []
+    
+    metadatas = cl.user_session.get("metadatas")
+    all_sources = [m["source"] for m in metadatas]
+    texts = cl.user_session.get("texts")
+    
+    if sources:
+        found_sources = []
+        for src in sources.split(","):
+            source_name = src.strip().replace(".", "")
+            try:
+                index = all_sources.index(source_name)
+            except ValueError:
+                continue
+            found_sources.append(source_name)
+            source_elements.append(cl.Text(content=texts[index], name=source_name))
+        if found_sources:
+            answer += f"\nFUENTES: {', '.join(found_sources)}"
+        else:
+            answer += "\nNo se encontraron fuentes."
+    
+    if cb.has_streamed_final_answer:
+        cb.final_stream.elements = source_elements
+        await cb.final_stream.update()
+    else:
+        await cl.Message(content=answer, elements=source_elements).send()
+
+# --- EJECUCIÓN ---
+if __name__ == "__main__":
+    from chainlit.cli import run_chainlit
+    file_name = __file__ if '__file__' in globals() else "app.py"
+    run_chainlit(file_name)