Update app.py

app.py

@@ -1,10 +1,10 @@
 import os
-import inspect
 import chainlit as cl
 import PyPDF2
 import httpx
 import requests
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any
+from markdown import markdown
 
 from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain.vectorstores import Chroma
@@ -15,9 +15,9 @@ from langchain.prompts.chat import (
     HumanMessagePromptTemplate,
 )
 
-# Configuración Deepseek
+# Configuración Deepseek Actualizada
 DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY")
-EMBEDDINGS_URL = "https://api.deepseek.com/v1/embeddings"
+EMBEDDINGS_URL = "https://api.deepseek.com/v1/embeddings"  # URL corregida
 CHAT_URL = "https://api.deepseek.com/v1/chat/completions"
 
 class DeepseekEmbeddings:
@@ -30,19 +30,17 @@ class DeepseekEmbeddings:
             "Content-Type": "application/json"
         }
         
-        embeddings = []
-        for text in texts:
-            data = {
-                "input": text,
-                "model": "text-embedding-001",
-                "encoding_type": "float"
-            }
-            response = requests.post(EMBEDDINGS_URL, json=data, headers=headers)
-            if response.status_code == 200:
-                embeddings.append(response.json()['data'][0]['embedding'])
-            else:
-                raise ValueError(f"Error en embeddings: {response.text}")
-        return embeddings
+        data = {
+            "input": texts,
+            "model": "deepseek-embedding",  # Modelo actualizado
+            "encoding_type": "float"
+        }
+        
+        response = requests.post(EMBEDDINGS_URL, json=data, headers=headers)
+        if response.status_code == 200:
+            return [item["embedding"] for item in response.json()["data"]]
+        else:
+            raise ValueError(f"Error en embeddings: {response.text}")
 
 class DeepseekChat:
     def __init__(self, api_key: str):
@@ -68,31 +66,24 @@ class DeepseekChat:
             return response.json()['choices'][0]['message']['content']
         raise ValueError(f"Error en el chat: {response.text}")
 
-system_template = """Analiza en profundidad los siguientes documentos para responder la pregunta. Realiza:
-1. Comparación crítica entre fuentes
-2. Detección de patrones y contradicciones
-3. Síntesis de información cruzada
-4. Inferencias lógicas basadas en el contexto
-5. Identificación de relaciones implícitas
-
-Incluye siempre:
-- Conclusiones fundamentadas
-- Evaluación de consistencia entre documentos
-- Posibles implicaciones prácticas
-- FUENTES utilizadas (máximo 3 relevantes)
+system_template = """Eres un experto en gestión de conflictos con habilidades avanzadas de análisis. Puedes:
+1. Responder preguntas generales y técnicas
+2. Generar tablas comparativas en markdown
+3. Analizar documentos en profundidad
+4. Combinar múltiples fuentes de información
 
-Ejemplo de respuesta:
-[Análisis principal] 
-[Comparación de enfoques] 
-[Conclusiones] 
-FUENTES: x, y, z
+Instrucciones:
+- Usa formato markdown para tablas y listas
+- Para preguntas técnicas, usa los documentos como fuente principal
+- Incluye siempre fuentes relevantes
+- Si no hay información suficiente, indica qué aspectos no están cubiertos en los documentos
 
-Contexto:
+Contexto documental:
 {summaries}"""
 
 messages = [
     SystemMessagePromptTemplate.from_template(system_template),
-    HumanMessagePromptTemplate.from_template("Pregunta: {question}\nRespuesta completa:")
+    HumanMessagePromptTemplate.from_template("**Pregunta:** {question}\n**Respuesta (usar markdown si es necesario):**")
 ]
 prompt = ChatPromptTemplate.from_messages(messages)
 
@@ -100,91 +91,103 @@ text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=20
 
 @cl.on_chat_start
 async def on_chat_start():
-    await cl.Message(content="Bienvenido al analizador avanzado de gestión de conflictos").send()
+    await cl.Message(content="Bienvenido al sistema experto en gestión de conflictos").send()
     
     pdf_paths = [
-        'gestios de conflictos.pdf',
-        'Managing Conflict with Your Boss .pdf'
+        "gestion de conflictos.pdf",
+        "Managing Conflict with Your Boss .pdf"
     ]
     
     all_texts = []
     all_metadatas = []
     
     for path in pdf_paths:
-        base_name = os.path.basename(path)
-        with open(path, "rb") as f:
-            reader = PyPDF2.PdfReader(f)
-            pdf_text = " ".join([page.extract_text() for page in reader.pages if page.extract_text()])
-            chunks = text_splitter.split_text(pdf_text)
-            all_texts.extend(chunks)
-            all_metadatas.extend([{
-                "source": base_name,
-                "page": (i // 3) + 1  # Estimación de página
-            } for i, _ in enumerate(chunks)])
+        try:
+            base_name = os.path.basename(path)
+            with open(path, "rb") as f:
+                reader = PyPDF2.PdfReader(f)
+                pdf_text = " ".join([page.extract_text() or "" for page in reader.pages])
+                chunks = text_splitter.split_text(pdf_text)
+                all_texts.extend(chunks)
+                all_metadatas.extend([{
+                    "source": base_name,
+                    "page": (i // 3) + 1
+                } for i, _ in enumerate(chunks)])
+        except Exception as e:
+            await cl.Message(content=f"Error cargando {path}: {str(e)}").send()
+            return
     
-    embeddings = DeepseekEmbeddings(DEEPSEEK_API_KEY)
-    docsearch = await cl.make_async(Chroma.from_texts)(
-        all_texts,
-        embeddings,
-        metadatas=all_metadatas,
-        collection_metadata={"hnsw:space": "cosine"}
-    )
+    try:
+        embeddings = DeepseekEmbeddings(DEEPSEEK_API_KEY)
+        docsearch = await cl.make_async(Chroma.from_texts)(
+            all_texts,
+            embeddings,
+            metadatas=all_metadatas
+        )
+    except Exception as e:
+        await cl.Message(content=f"Error creando embeddings: {str(e)}").send()
+        return
     
-    chain = RetrievalQAWithSourcesChain.from_chain_type(
-        DeepseekChat(DEEPSEEK_API_KEY),
-        chain_type="stuff",
-        retriever=docsearch.as_retriever(search_kwargs={"k": 5}),
-        return_source_documents=True,
-        chain_type_kwargs={"prompt": prompt}
-    )
+    try:
+        chain = RetrievalQAWithSourcesChain.from_chain_type(
+            DeepseekChat(DEEPSEEK_API_KEY),
+            chain_type="stuff",
+            retriever=docsearch.as_retriever(search_kwargs={"k": 3}),
+            return_source_documents=True,
+            chain_type_kwargs={"prompt": prompt}
+        )
+    except Exception as e:
+        await cl.Message(content=f"Error configurando la cadena: {str(e)}").send()
+        return
     
     cl.user_session.set("chain", chain)
     cl.user_session.set("metadatas", all_metadatas)
     cl.user_session.set("texts", all_texts)
     
-    await cl.Message(content="Sistema listo. Puedes realizar preguntas complejas para análisis detallado").send()
+    await cl.Message(content="Sistema listo. Puedes hacer preguntas o pedir análisis con tablas").send()
 
 @cl.on_message
 async def main(message: cl.Message):
     query = message.content
     chain = cl.user_session.get("chain")
-    cb = cl.AsyncLangchainCallbackHandler()
     
     try:
-        res = await chain.acall(query, callbacks=[cb])
+        res = await chain.acall(query)
         answer = res["answer"]
-        sources = res.get("sources", "").split(",")
         
+        # Formatear markdown
+        formatted_answer = markdown(answer)
+        
+        # Manejo de fuentes
+        sources = res.get("sources", "")
         metadatas = cl.user_session.get("metadatas")
         texts = cl.user_session.get("texts")
         
-        source_details = []
+        source_elements = []
         unique_sources = set()
-        for src in sources:
+        
+        for src in sources.split(","):
             src = src.strip()
-            if not src:
-                continue
-            matches = [i for i, m in enumerate(metadatas) if m["source"] == src]
-            if matches:
-                unique_sources.add(src)
-                source_details.extend([
-                    cl.Text(
-                        content=texts[i],
-                        name=f"{src} (Página {metadatas[i]['page']})"
-                    ) for i in matches[:2]  # Mostrar máximo 2 fragmentos por fuente
-                ])
+            if src:
+                matches = [i for i, m in enumerate(metadatas) if m["source"] == src]
+                if matches:
+                    unique_sources.add(src)
+                    source_elements.append(cl.Text(
+                        content=texts[matches[0]],
+                        name=f"{src} (Página {metadatas[matches[0]]['page']})"
+                    ))
         
         if unique_sources:
-            answer += f"\n\nFUENTES ANALIZADAS: {', '.join(sorted(unique_sources))}"
-            answer += "\n\nFragmentos relevantes:"
+            formatted_answer += f"\n\n**Fuentes verificadas:** {', '.join(unique_sources)}"
         
         await cl.Message(
-            content=answer,
-            elements=source_details[:4]  # Mostrar máximo 4 fragmentos
+            content=formatted_answer,
+            elements=source_elements[:3],
+            language="markdown"
         ).send()
     
     except Exception as e:
-        await cl.Message(content=f"Error en el análisis: {str(e)}").send()
+        await cl.Message(content=f"Error procesando la consulta: {str(e)}").send()
 
 if __name__ == "__main__":
     from chainlit.cli import run_chainlit