Update app.py

app.py

@@ -1,94 +1,79 @@
 import os
-import json
+import asyncio
 import traceback
 import chainlit as cl
-import httpx  # Importamos a nova biblioteca
+from groq import Groq
 
-# 1. Configurações do Modelo e API
+# 1. Configuração do Cliente Groq
+client = Groq()
+
+# 2. Configurações do Modelo
 MODEL_ID = "groq/compound"
-GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
-API_URL = "https://api.groq.com/openai/v1/chat/completions"
 
-# 2. Início do Chat
+# 3. Início do Chat
 @cl.on_chat_start
 def start_chat():
-    """Define o prompt de sistema para guiar o comportamento do modelo."""
     system_prompt = (
         "Você é um assistente de pesquisa avançado. "
         "Quando um usuário perguntar sobre o conteúdo de um site (ex: 'o que tem no site X?'), "
         "sua tarefa é usar internamente as ferramentas 'visit_website' ou 'web_search' para obter as informações. "
-        "Após coletar os dados, você deve fornecer uma resposta final completa, bem estruturada e detalhada em markdown, "
-        "organizando o conteúdo em seções claras com títulos e listas, como um resumo executivo."
+        "Após coletar os dados, você deve fornecer uma resposta final completa, bem estruturada e detalhada em markdown."
     )
     cl.user_session.set(
         "message_history",
         [{"role": "system", "content": system_prompt}]
     )
 
-# 3. Lógica Principal de Mensagem (usando httpx)
+# 4. Lógica Principal (Modelo Robusto)
 @cl.on_message
 async def main(message: cl.Message):
-    """Processa a mensagem do usuário usando httpx para mais controle sobre o stream."""
     message_history = cl.user_session.get("message_history")
     message_history.append({"role": "user", "content": message.content})
 
-    msg = cl.Message(content="")
-    await msg.send()
+    # Mensagem de status para o usuário saber que algo está acontecendo
+    status_msg = cl.Message(content="Processando sua solicitação com a Groq...")
+    await status_msg.send()
 
-    full_response = ""
     try:
-        # Montamos os headers e o payload manualmente
-        headers = {
-            "Authorization": f"Bearer {GROQ_API_KEY}",
-            "Content-Type": "application/json",
-        }
-        
-        payload = {
-            "model": MODEL_ID,
-            "messages": message_history,
-            "temperature": 0.7,
-            "max_tokens": 4096,
-            "stream": True,  # Essencial para o streaming
-            "compound_custom": {"tools": {"enabled_tools": ["web_search", "code_interpreter", "visit_website"]}}
-        }
+        # --- ETAPA 1: BUSCAR A RESPOSTA COMPLETA (SEM STREAMING) ---
+        # Esta é a mudança crucial. Fazemos uma chamada bloqueante (assíncrona)
+        # para obter a resposta inteira de uma vez.
+        response = client.chat.completions.create(
+            model=MODEL_ID,
+            messages=message_history,
+            temperature=0.7,
+            max_tokens=4096,
+            stream=False,  # MUDANÇA CRÍTICA
+            compound_custom={"tools": {"enabled_tools": ["web_search", "code_interpreter", "visit_website"]}}
+        )
+
+        full_response = response.choices[0].message.content
 
-        # Usamos um AsyncClient do httpx para fazer a requisição
-        async with httpx.AsyncClient(timeout=60) as client:
-            # client.stream nos dá um objeto de resposta para iterar
-            async with client.stream("POST", API_URL, headers=headers, json=payload) as response:
-                # Verificamos se a requisição foi bem-sucedida
-                response.raise_for_status()
-                
-                # Iteramos sobre as linhas da resposta (formato SSE)
-                async for line in response.aiter_lines():
-                    if line.startswith("data: "):
-                        # Removemos o prefixo "data: "
-                        json_data = line.removeprefix("data: ").strip()
-                        
-                        # O stream termina com um sinal "[DONE]"
-                        if json_data == "[DONE]":
-                            break
-                        
-                        # Convertemos o texto JSON em um dicionário Python
-                        chunk = json.loads(json_data)
+        # Remove a mensagem de status "Processando..."
+        await status_msg.remove()
+
+        # --- ETAPA 2: "TRANSMITIR" A RESPOSTA JÁ RECEBIDA PARA A INTERFACE ---
+        # Simulamos o streaming para uma melhor experiência do usuário.
+        if full_response and full_response.strip():
+            msg = cl.Message(content="")
+            await msg.send()
+            
+            for token in full_response:
+                await msg.stream_token(token)
+                # Um pequeno atraso para tornar o streaming visível
+                await asyncio.sleep(0.005) 
+            
+            await msg.update()
+            
+            # Adiciona a resposta final ao histórico
+            message_history.append({"role": "assistant", "content": full_response})
+            cl.user_session.set("message_history", message_history)
+        else:
+            await cl.Message(content="O modelo não retornou uma resposta.").send()
 
-                        # Extraímos o token de texto, se existir
-                        if chunk["choices"] and chunk["choices"][0]["delta"].get("content"):
-                            token = chunk["choices"][0]["delta"]["content"]
-                            await msg.stream_token(token)
-                            full_response += token
-    
     except Exception as e:
+        # Se a chamada à API falhar, removemos o status e mostramos o erro.
+        await status_msg.remove()
         print(f"--- ERRO INESPERADO CAPTURADO ---")
         traceback.print_exc()
-        await msg.update(content=f"Desculpe, ocorreu um erro: {e}")
-        return
-
-    # Finaliza a mensagem e atualiza o histórico
-    if full_response.strip():
-        await msg.update()
-        message_history.append({"role": "assistant", "content": full_response})
-        cl.user_session.set("message_history", message_history)
-    else:
-        # Se não houve resposta, informa o usuário e remove a mensagem vazia
-        await msg.update(content="O modelo não gerou uma resposta desta vez.")
+        await cl.Message(content=f"Desculpe, ocorreu um erro: {e}").send()