Update app.py

app.py

@@ -1,135 +1,84 @@
 import os
-import json
-import traceback
 import chainlit as cl
 from groq import Groq
 
 # 1. Configuração do Cliente Groq
-# Certifique-se de que a variável de ambiente GROQ_API_KEY está definida.
-client = Groq(
-    api_key=os.environ.get("GROQ_API_KEY"),
-)
+# A API key será lida da variável de ambiente GROQ_API_KEY.
+client = Groq()
 
-# 2. Definição do Modelo
+# 2. Configurações do Modelo
 MODEL_ID = "groq/compound"
 
-# 3. Implementação das Ferramentas (Placeholders)
-def execute_tool(tool_call: dict) -> str:
-    """Executa uma ferramenta com base na chamada da API e retorna o resultado como uma string."""
-    tool_name = tool_call.function.name
-    try:
-        args = json.loads(tool_call.function.arguments)
-    except json.JSONDecodeError:
-        return f"Erro: Argumentos JSON inválidos para a ferramenta {tool_name}."
-
-    print(f"--- EXECUTANDO FERRAMENTA ---")
-    print(f"Nome: {tool_name}")
-    print(f"Argumentos: {args}")
-    print(f"--------------------------")
-
-    if tool_name == "web_search":
-        query = args.get("query", "")
-        # Em um app real, aqui você faria a busca na web.
-        return f"Resultado da busca na web para '{query}': A Groq é uma empresa de tecnologia que desenvolve o LPU (Language Processing Unit), um novo tipo de processador para cargas de trabalho de IA."
-    
-    elif tool_name == "code_interpreter":
-        code = args.get("code", "")
-        # Em um app real, aqui você executaria o código de forma segura.
-        return f"Resultado da execução do código '{code}': O resultado é 42."
-    
-    else:
-        return f"Erro: Ferramenta desconhecida '{tool_name}'"
-
-# 4. Início do Chat
+# 3. Início do Chat
 @cl.on_chat_start
 def start_chat():
-    """Inicializa o histórico da conversa quando um novo chat começa."""
+    """
+    Define um prompt de sistema detalhado para instruir o modelo a se comportar
+    como um assistente de pesquisa que resume o conteúdo de websites.
+    """
+    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."
+    )
     cl.user_session.set(
         "message_history",
-        [{"role": "system", "content": "Você é um assistente poderoso que pode navegar na web e executar código para responder às perguntas dos usuários."}]
+        [{"role": "system", "content": system_prompt}]
     )
 
-# 5. Lógica Principal de Mensagem
+# 4. Lógica Principal de Mensagem (com Depuração)
 @cl.on_message
 async def main(message: cl.Message):
-    """Processa cada nova mensagem do usuário."""
+    """
+    Processa cada nova mensagem do usuário com uma única chamada de streaming para a API
+    e exibe os chunks brutos da resposta nos logs.
+    """
+    # Recupera e atualiza o histórico da conversa
     message_history = cl.user_session.get("message_history")
     message_history.append({"role": "user", "content": message.content})
 
-    # NOVO: Exibe uma mensagem de status imediata para o usuário.
-    status_msg = cl.Message(content="Aguardando resposta da Groq...")
-    await status_msg.send()
+    # Cria a mensagem de resposta vazia para o streaming
+    msg = cl.Message(content="")
+    await msg.send()
 
     try:
-        # PRIMEIRA CHAMADA (Não-Streaming): Decide a ação do modelo.
-        async with cl.Step(name="Pensando...", show_input=False):
-            response = client.chat.completions.create(
-                model=MODEL_ID,
-                messages=message_history,
-                temperature=1,
-                max_completion_tokens=1024,
-                top_p=1,
-                stream=True,
-                stop=None,
-                compound_custom={"tools":{"enabled_tools":["web_search","code_interpreter","visit_website"]}}
-            )
-                
-            
-
-            # NOVO: Exibe o log da resposta bruta no console para depuração.
-            print("--- RESPOSTA BRUTA DA API GROQ ---")
-            print(response.model_dump_json(indent=2))
-            print("---------------------------------")
-            
-            response_message = response.choices[0].message
-        
-        # CASO 1: O modelo decidiu usar uma ferramenta.
-        if response_message.tool_calls:
-            tool_call = response_message.tool_calls[0]
-            
-            async with cl.Step(name="Executando Ferramenta", show_input=False) as tool_step:
-                tool_step.input = f"Ferramenta: {tool_call.function.name}"
-                tool_output = execute_tool(tool_call)
-                tool_step.output = tool_output
-            
-            message_history.append(response_message)
-            message_history.append({"role": "tool", "tool_call_id": tool_call.id, "content": tool_output})
+        # Realiza a chamada única e direta para a API, com streaming ativado
+        stream = client.chat.completions.create(
+            model=MODEL_ID,
+            messages=message_history,
+            temperature=0.7,
+            max_tokens=4096,
+            stream=True,
+            # Parâmetros essenciais para o modelo 'groq/compound' usar ferramentas
+            compound_custom={"tools": {"enabled_tools": ["web_search", "code_interpreter", "visit_website"]}}
+        )
 
-            # SEGUNDA CHAMADA (Streaming): Gera a resposta final.
-            final_stream = client.chat.completions.create(
-                model=MODEL_ID, messages=message_history, stream=True
-            )
-            
-            msg = cl.Message(content="")
-            await msg.send()
-            full_response = ""
-            for chunk in final_stream:
-                if chunk.choices[0].delta.content:
-                    token = chunk.choices[0].delta.content
-                    await msg.stream_token(token)
-                    full_response += token
-            
-            if full_response:
-                message_history.append({"role": "assistant", "content": full_response})
-            await msg.update()
+        # Processa o stream e exibe a resposta token a token
+        full_response = ""
+        for chunk in stream:
+            # --- LOG DE DEPURAÇÃO ADICIONADO AQUI ---
+            # Exibe cada chunk bruto recebido da API no console para análise.
+            print("--- CHUNK BRUTO RECEBIDO ---")
+            print(chunk.model_dump_json(indent=2))
+            print("----------------------------")
 
-        # CASO 2: O modelo respondeu diretamente.
-        elif response_message.content:
-            await cl.Message(content=response_message.content).send()
-            message_history.append({"role": "assistant", "content": response_message.content})
+            # Verifica se o 'chunk' (pedaço) da resposta contém conteúdo de texto
+            if chunk.choices and chunk.choices[0].delta.content:
+                token = chunk.choices[0].delta.content
+                await msg.stream_token(token)
+                full_response += token
         
-        # CASO 3: Resposta inesperada.
-        else:
-            await cl.Message(content="Ocorreu um erro: O modelo não retornou uma resposta válida.").send()
+        # Atualiza a mensagem final e o histórico da conversa com a resposta completa
+        await msg.update()
+        if full_response:
+            message_history.append({"role": "assistant", "content": full_response})
+            cl.user_session.set("message_history", message_history)
 
     except Exception as e:
-        print(f"--- ERRO INESPERADO CAPTURADO ---")
+        # Captura e exibe qualquer erro que possa ocorrer durante a chamada da API
+        print(f"Ocorreu um erro inesperado: {e}")
+        import traceback
         traceback.print_exc()
-        await cl.Message(content=f"Ocorreu um erro crítico na aplicação: {e}").send()
-    
-    finally:
-        # NOVO: Remove a mensagem de status "Aguardando..." ao final do processo.
-        await status_msg.remove()
-
-    # Salva o histórico atualizado.
-    cl.user_session.set("message_history", message_history)
+        await msg.update(content=f"Desculpe, ocorreu um erro ao processar sua solicitação: {e}")