Update frontend/app.py

frontend/app.py

@@ -4,15 +4,10 @@ import chainlit as cl
 import httpx
 import os 
 
-# URL do nosso backend FastAPI
-# Se estiver rodando no Docker, localhost geralmente funciona se usar network host, 
-# mas em bridge pode precisar do nome do serviço. 
-# Mantendo localhost conforme seu log de sucesso anterior (200 OK).
 API_URL = "http://localhost:8000"
 UPLOAD_URL = f"{API_URL}/upload-document"
 CHAT_URL = f"{API_URL}/chat"
 
-# Flag para saber se o RAG está inicializado
 RAG_INITIALIZED = False
 
 @cl.on_chat_start
@@ -20,15 +15,13 @@ async def start():
     global RAG_INITIALIZED
     RAG_INITIALIZED = False
 
-    # Mensagem de instrução inicial
     await cl.Message(
-        content="Olá! Para começar, por favor, **faça o upload de um arquivo PDF** para eu usar como contexto. Após o upload, poderemos conversar sobre o conteúdo do documento.",
+        content="👋 **Bem-vindo ao RAG Llama 3.3!**\n\nPara começar, faça o upload de um PDF. Vou ler o conteúdo e criar uma base de conhecimento para responder suas perguntas.",
         author="Sistema"
     ).send()
 
-    # Pede o upload do arquivo
     files = await cl.AskFileMessage(
-        content="Faça o upload do PDF:",
+        content="📂 Por favor, envie seu arquivo PDF:",
         accept=["application/pdf"],
         max_size_mb=20,
         timeout=180,
@@ -36,47 +29,44 @@ async def start():
 
     if files:
         file = files[0]
-        # Inicia a mensagem de "Processando"
-        msg = cl.Message(content=f"Recebido: {file.name}. Processando...", author="Sistema")
+        msg = cl.Message(content=f"⏳ Processando '{file.name}'...", author="Sistema")
         await msg.send()
         
         try:
-            # 1. Obtendo o MIME Type de forma robusta
             mime_type = getattr(file, 'type', 'application/pdf') or 'application/pdf'
             
-            # 2. Lendo o conteúdo do arquivo
             with open(file.path, "rb") as f:
                 file_content = f.read()
 
-            # 3. Criando o payload
             files_payload = {
                 "file": (file.name, file_content, mime_type)
             }
 
-            # 4. Envia o arquivo para o backend
             async with httpx.AsyncClient(timeout=300) as client:
-                response = await client.post(
-                    UPLOAD_URL, 
-                    files=files_payload
-                )
+                response = await client.post(UPLOAD_URL, files=files_payload)
                 
-                # CORREÇÃO AQUI: Atualiza o atributo content e depois chama update() sem argumentos
                 if response.status_code == 200:
                     RAG_INITIALIZED = True
-                    msg.content = f"✅ Documento '{file.name}' processado com sucesso! Agora você pode fazer perguntas sobre o conteúdo do documento."
+                    data = response.json()
+                    chunks = data.get("total_chunks", "?")
+                    pages = data.get("total_pages", "?")
+                    
+                    msg.content = (
+                        f"✅ **Processamento Concluído!**\n\n"
+                        f"📄 Arquivo: `{file.name}`\n"
+                        f"📑 Páginas lidas: {pages}\n"
+                        f"✂️ Segmentos gerados (Chunks): {chunks}\n\n"
+                        f"Agora você pode perguntar qualquer coisa sobre o documento!"
+                    )
                     await msg.update()
                 else:
                     RAG_INITIALIZED = False
                     error_detail = response.json().get('detail', 'Erro desconhecido')
-                    msg.content = f"❌ Erro ao processar o arquivo. Código: {response.status_code}. Detalhe: {error_detail}"
+                    msg.content = f"❌ Erro ao processar. Código: {response.status_code}. Detalhe: {error_detail}"
                     await msg.update()
 
-        except httpx.ConnectError:
-            msg.content = "Erro de conexão: Não foi possível se conectar ao backend. Verifique se ele está rodando."
-            await msg.update()
-            
         except Exception as e:
-            msg.content = f"Ocorreu um erro: {e}"
+            msg.content = f"❌ Ocorreu um erro crítico: {e}"
             await msg.update()
         
 @cl.on_message
@@ -85,42 +75,72 @@ async def main(message: cl.Message):
     
     if not RAG_INITIALIZED:
         await cl.Message(
-            content="Por favor, aguarde o processamento do arquivo ou recarregue a página para um novo upload. Nenhum documento foi processado ainda.",
+            content="⚠️ Nenhum documento carregado. Por favor, recarregue a página para enviar um PDF.",
             author="Sistema"
         ).send()
         return
 
-    # Cria uma mensagem de resposta vazia para preencher com o stream
+    # 1. Cria a mensagem principal
     msg = cl.Message(content="")
     await msg.send()
 
+    # 2. Cria o Step de Auditoria (inicialmente rodando)
+    audit_step = cl.Step(name="🔎 Processando & Auditoria", type="process")
+    audit_step.input = message.content
+    await audit_step.send()
+
+    # Buffer para detectar o separador de debug
+    debug_separator = "###__DEBUG__###"
+    is_debug_mode = False
+    debug_content = ""
+
     try:
         async with httpx.AsyncClient(timeout=60) as client:
             async with client.stream("POST", CHAT_URL, json={"content": message.content}) as response:
                 if response.status_code != 200:
-                    try:
-                        error_text = await response.aread()
-                        error_detail = error_text.decode('utf-8')
-                    except Exception:
-                        error_detail = f"Status Code: {response.status_code}"
-
-                    # CORREÇÃO AQUI TAMBÉM
-                    msg.content = f"❌ Erro na comunicação com o serviço de IA. Detalhe: {error_detail}"
+                    msg.content = f"❌ Erro na IA: {response.status_code}"
                     await msg.update()
+                    audit_step.status = "failed"
+                    await audit_step.update()
                     return
 
-                # Streaming
                 async for chunk in response.aiter_text():
-                    await msg.stream_token(chunk)
+                    # Se já estamos no modo debug, acumulamos apenas no Step
+                    if is_debug_mode:
+                        debug_content += chunk
+                        continue
+
+                    # Verifica se o chunk contém o início do separador
+                    if debug_separator in chunk:
+                        parts = chunk.split(debug_separator)
+                        
+                        # Parte 1: Final da resposta normal
+                        if parts[0]:
+                            await msg.stream_token(parts[0])
+                        
+                        # Ativa modo debug e guarda o resto
+                        is_debug_mode = True
+                        if len(parts) > 1:
+                            debug_content += parts[1]
+                    else:
+                        # Fluxo normal de texto para o usuário
+                        await msg.stream_token(chunk)
         
-        # Finaliza a mensagem (stream_token atualiza automaticamente, update final garante persistência)
+        # Finalização
         await msg.update()
+        
+        # Atualiza o Step com o conteúdo de auditoria (Contexto recuperado)
+        if debug_content:
+            audit_step.output = debug_content
+        else:
+            audit_step.output = "Nenhum contexto adicional retornado."
+            
+        await audit_step.update()
 
-    except httpx.ConnectError:
-        msg.content = "Erro de conexão: Não foi possível se conectar ao backend. Verifique se ele está rodando."
-        await msg.update()
     except Exception as e:
-        msg.content = f"Ocorreu um erro: {e}"
+        msg.content = f"❌ Erro de conexão: {e}"
         await msg.update()
+        audit_step.status = "failed"
+        await audit_step.update()
 
 #--- END OF FILE app.py ---