Update app.py

app.py

@@ -1,4 +1,5 @@
 import os
+import json
 import chainlit as cl
 from groq import Groq
 
@@ -7,58 +8,124 @@ client = Groq(
     api_key=os.environ.get("GROQ_API_KEY"),
 )
 
-# Configurações do Modelo
-MODEL_ID = "groq/compound" # Agora está correto, pois vamos passar os parâmetros necessários
+# --- PASSO 1: Usar o modelo de agente 'groq/compound' ---
+MODEL_ID = "groq/compound"
+
+# --- PASSO 2: Criar uma função para executar as ferramentas ---
+# A Groq não executa as ferramentas por você; ela apenas lhe diz QUAL ferramenta executar.
+# Nós precisamos implementar a lógica para cada ferramenta aqui.
+# Por enquanto, estas são implementações FALSAS (placeholders) para demonstração.
+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 inválidos para a ferramenta {tool_name}."
+
+    print(f"Executando ferramenta: {tool_name} com argumentos: {args}")
+
+    # Implementação real das ferramentas iria aqui
+    if tool_name == "web_search":
+        # Em um app real, você usaria bibliotecas como 'requests' e 'BeautifulSoup'
+        query = args.get("query", "")
+        return f"Resultado da busca na web para '{query}': A Groq é uma empresa de tecnologia que desenvolve o LPU (Language Processing Unit)."
+    
+    elif tool_name == "code_interpreter":
+        # Em um app real, você usaria 'exec()' ou um sandbox para executar o código
+        code = args.get("code", "")
+        return f"Resultado da execução do código '{code}': O resultado é 42."
+    
+    # Adicione outras ferramentas aqui (visit_website, browser_automation)
+    
+    else:
+        return f"Erro: Ferramenta desconhecida '{tool_name}'"
+
 
 @cl.on_chat_start
 def start_chat():
-    # Inicializa o histórico da conversa na sessão do usuário
     cl.user_session.set(
         "message_history",
-        [{"role": "system", "content": "Você é um assistente inteligente e útil, capaz de usar ferramentas como pesquisa na web."}]
+        [{"role": "system", "content": "Você é um assistente poderoso que pode navegar na web e executar código para responder às perguntas dos usuários."}]
     )
 
 @cl.on_message
 async def main(message: cl.Message):
-    # Recupera o histórico
     message_history = cl.user_session.get("message_history")
-    
-    # Adiciona a nova mensagem do usuário
     message_history.append({"role": "user", "content": message.content})
 
-    # Cria a mensagem de resposta vazia para streaming
-    msg = cl.Message(content="")
-    await msg.send()
-
-    # Chamada à API do Groq com Streaming
-    stream = client.chat.completions.create(
-        messages=message_history,
-        model=MODEL_ID,
-        temperature=0.7,
-        max_tokens=1024,
-        stream=True,
-        # --- PARÂMETRO OBRIGATÓRIO ADICIONADO AQUI ---
-        compound_custom={
-            "tools": {
-                "enabled_tools": [
-                    "web_search",
-                    "code_interpreter",
-                    "visit_website",
-                    "browser_automation"
-                ]
+    # --- PASSO 3: Lógica do Agente (Ciclo de duas chamadas) ---
+    while True:
+        # Define os parâmetros obrigatórios para o 'groq/compound'
+        compound_params = {
+            "model": MODEL_ID,
+            "messages": message_history,
+            "temperature": 0.7,
+            "max_tokens": 4096, # Aumentado para permitir respostas mais longas
+            "stream": False, # A primeira chamada NÃO PODE ser streaming, precisamos da resposta completa
+            "compound_custom": {
+                "tools": {
+                    "enabled_tools": [
+                        "web_search",
+                        "code_interpreter" # Removido visit_website e browser_automation por simplicidade
+                    ]
+                }
             }
         }
-    )
+        
+        # Primeira chamada para a API para obter a chamada da ferramenta
+        async with cl.Step(name="Pensando...", show_input=False) as thinking_step:
+            thinking_step.output = "O modelo está decidindo qual ferramenta usar..."
+            response = client.chat.completions.create(**compound_params)
+            response_message = response.choices[0].message
 
-    # Processa o stream
-    for chunk in stream:
-        if chunk.choices[0].delta.content:
-            token = chunk.choices[0].delta.content
-            await msg.stream_token(token)
+        # Se a resposta contiver uma chamada de ferramenta
+        if response_message.tool_calls:
+            tool_calls = response_message.tool_calls
+            # Adiciona a resposta do assistente (com a chamada da ferramenta) ao histórico
+            message_history.append(response_message)
+            
+            async with cl.Step(name="Executando Ferramenta", show_input=False) as tool_step:
+                tool_step.input = f"Ferramenta: {tool_calls[0].function.name}, Argumentos: {tool_calls[0].function.arguments}"
+                
+                # Executa a ferramenta
+                tool_output = execute_tool(tool_calls[0])
+                tool_step.output = tool_output
+                
+                # Adiciona o resultado da ferramenta ao histórico
+                message_history.append({
+                    "role": "tool",
+                    "tool_call_id": tool_calls[0].id,
+                    "content": tool_output,
+                })
+            
+            # Continua o loop para a próxima chamada da API, que gerará a resposta final
+            continue
 
-    # Atualiza o histórico com a resposta completa do assistente
-    if msg.content:
-      message_history.append({"role": "assistant", "content": msg.content})
-      cl.user_session.set("message_history", message_history)
-    
-    await msg.update()
+        # Se não houver chamada de ferramenta, o modelo deu uma resposta final
+        else:
+            # Agora fazemos a SEGUNDA chamada, desta vez COM STREAMING, para a resposta final
+            final_stream_params = compound_params.copy()
+            final_stream_params["stream"] = True
+            
+            stream = client.chat.completions.create(**final_stream_params)
+
+            # Envia a resposta final para a interface do usuário
+            msg = cl.Message(content="")
+            await msg.send()
+            
+            full_response = ""
+            for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    token = chunk.choices[0].delta.content
+                    await msg.stream_token(token)
+                    full_response += token
+            
+            # Adiciona a resposta final do assistente ao histórico
+            if full_response:
+                message_history.append({"role": "assistant", "content": full_response})
+            
+            await msg.update()
+            break # Sai do loop while
+
+    cl.user_session.set("message_history", message_history)