Upload 17 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -1,32 +1,32 @@
-# Usa uma imagem base leve do Python 3.10
-FROM python:3.10-slim
-
-# 1. A MÁGICA DO SISTEMA (Instala o que falta)
-# ffmpeg: Para o áudio (Scholar Podcast)
-# graphviz: Para os mapas mentais
-RUN apt-get update && apt-get install -y \
-    ffmpeg \
-    graphviz \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-# Configura o diretório de trabalho
-WORKDIR /app
-
-# Copia os requisitos e instala as bibliotecas Python
-COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copia todo o restante do código
-COPY . .
-
-# 2. A MÁGICA DAS PERMISSÕES
-# Cria a pasta onde os arquivos serão salvos e dá permissão total
-# Isso evita erros de "Permission Denied" quando a IA tentar salvar o MP3
-RUN mkdir -p backend/generated && chmod -R 777 backend/generated
-
-# Expõe a porta que o Hugging Face usa
-EXPOSE 7860
-
-# Comando para iniciar a J.A.D.E.
+# Usa uma imagem base leve do Python 3.10
+FROM python:3.10-slim
+
+# 1. A MÁGICA DO SISTEMA (Instala o que falta)
+# ffmpeg: Para o áudio (Scholar Podcast)
+# graphviz: Para os mapas mentais
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    graphviz \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Configura o diretório de trabalho
+WORKDIR /app
+
+# Copia os requisitos e instala as bibliotecas Python
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copia todo o restante do código
+COPY . .
+
+# 2. A MÁGICA DAS PERMISSÕES
+# Cria a pasta onde os arquivos serão salvos e dá permissão total
+# Isso evita erros de "Permission Denied" quando a IA tentar salvar o MP3
+RUN mkdir -p backend/generated && chmod -R 777 backend/generated
+
+# Expõe a porta que o Hugging Face usa
+EXPOSE 7860
+
+# Comando para iniciar a J.A.D.E.
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,10 @@
----
-title: Jade Port
-emoji: 🦊
-colorFrom: green
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Jade Port
+emoji: 🦊
+colorFrom: green
+colorTo: indigo
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,141 +1,143 @@
-# app.py - VERSÃO COMPLETA COM VOZ (BASE64) E VISÃO
-import os
-import base64
-import io
-import asyncio
-from fastapi import FastAPI
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from pydantic import BaseModel 
-from PIL import Image
-from jade.core import JadeAgent 
-from jade.scholar import ScholarAgent
-from jade.heavy_mode import JadeHeavyAgent
-
-print("Iniciando a J.A.D.E. com FastAPI...")
-jade_agent = JadeAgent() 
-scholar_agent = ScholarAgent()
-# Instantiate Heavy Agent. It uses environment variables.
-jade_heavy_agent = JadeHeavyAgent()
-
-print("J.A.D.E. pronta para receber requisições.")
-
-app = FastAPI(title="J.A.D.E. API")
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
-)
-
-# Mount generated directory for static files (PDFs, Images)
-os.makedirs("backend/generated", exist_ok=True)
-app.mount("/generated", StaticFiles(directory="backend/generated"), name="generated")
-
-# Dicionário global para armazenar sessões de usuários
-# Structure: user_sessions[user_id] = { "jade": [...], "scholar": [...], "heavy": [...] }
-user_sessions = {}
-
-class UserRequest(BaseModel):
-    user_input: str
-    image_base64: str | None = None
-    user_id: str | None = None
-    agent_type: str = "jade" # "jade", "scholar", "heavy"
-
-@app.post("/chat")
-async def handle_chat(request: UserRequest):
-    try:
-        user_id = request.user_id if request.user_id else "default_user"
-        agent_type = request.agent_type.lower()
-        
-        if user_id not in user_sessions:
-            print(f"Nova sessão criada para: {user_id}")
-            user_sessions[user_id] = {
-                "jade": [jade_agent.system_prompt],
-                "scholar": [],
-                "heavy": []
-            }
-        
-        # Ensure sub-keys exist
-        if "jade" not in user_sessions[user_id]: user_sessions[user_id]["jade"] = [jade_agent.system_prompt]
-        if "scholar" not in user_sessions[user_id]: user_sessions[user_id]["scholar"] = []
-        if "heavy" not in user_sessions[user_id]: user_sessions[user_id]["heavy"] = []
-
-        vision_context = None
-        if request.image_base64:
-            try:
-                header, encoded_data = request.image_base64.split(",", 1)
-                image_bytes = base64.b64decode(encoded_data)
-                pil_image = Image.open(io.BytesIO(image_bytes))
-                # Jade handles vision processing
-                vision_context = jade_agent.image_handler.process_pil_image(pil_image)
-            except Exception as img_e:
-                print(f"Erro ao processar imagem Base64: {img_e}")
-                vision_context = "Houve um erro ao analisar a imagem."
-
-        final_user_input = request.user_input if request.user_input else "Descreva a imagem em detalhes."
-
-        bot_response_text = ""
-        audio_path = None
-        
-        if agent_type == "scholar":
-            current_history = user_sessions[user_id]["scholar"]
-            bot_response_text, audio_path, updated_history = scholar_agent.respond(
-                history=current_history,
-                user_input=final_user_input,
-                user_id=user_id,
-                vision_context=vision_context
-            )
-            user_sessions[user_id]["scholar"] = updated_history
-            
-        elif agent_type == "heavy":
-            current_history = user_sessions[user_id]["heavy"]
-            # Heavy agent is async
-            bot_response_text, audio_path, updated_history = await jade_heavy_agent.respond(
-                history=current_history,
-                user_input=final_user_input,
-                user_id=user_id,
-                vision_context=vision_context
-            )
-            user_sessions[user_id]["heavy"] = updated_history
-            
-        else:
-            # Default to J.A.D.E.
-            current_history = user_sessions[user_id]["jade"]
-            # Jade agent is synchronous, run directly
-            bot_response_text, audio_path, updated_history = jade_agent.respond(
-                history=current_history,
-                user_input=final_user_input,
-                user_id=user_id,
-                vision_context=vision_context
-            )
-            user_sessions[user_id]["jade"] = updated_history
-
-        # Audio Logic
-        audio_base64 = None
-        if audio_path and os.path.exists(audio_path):
-            print(f"Codificando arquivo de áudio: {audio_path}")
-            with open(audio_path, "rb") as audio_file:
-                audio_bytes = audio_file.read()
-                audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
-            
-            # Remove only if temp file
-            if "backend/generated" not in audio_path:
-                os.remove(audio_path) 
-        
-        return {
-            "success": True,
-            "bot_response": bot_response_text,
-            "audio_base64": audio_base64 
-        }
-    except Exception as e:
-        print(f"Erro crítico no endpoint /chat: {e}")
-        return {"success": False, "error": str(e)}
-
-@app.get("/")
-def root():
-    return {"message": "Servidor J.A.D.E. com FastAPI está online."}
-
-if __name__ == "__main__":
-    import uvicorn
-    port = int(os.environ.get("PORT", 7860))
-    print(f"Iniciando o servidor Uvicorn em http://0.0.0.0:{port}")
-    uvicorn.run(app, host="0.0.0.0", port=port)
+# app.py - VERSÃO COMPLETA COM VOZ (BASE64) E VISÃO
+import os
+import base64
+import io
+import asyncio
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel 
+from PIL import Image
+from jade.core import JadeAgent 
+from jade.scholar import ScholarAgent
+from jade.heavy_mode import JadeHeavyAgent
+
+print("Iniciando a J.A.D.E. com FastAPI...")
+jade_agent = JadeAgent() 
+scholar_agent = ScholarAgent()
+# Instantiate Heavy Agent. It uses environment variables.
+jade_heavy_agent = JadeHeavyAgent()
+
+print("J.A.D.E. pronta para receber requisições.")
+
+app = FastAPI(title="J.A.D.E. API")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
+)
+
+# Mount generated directory for static files (PDFs, Images)
+os.makedirs("backend/generated", exist_ok=True)
+app.mount("/generated", StaticFiles(directory="backend/generated"), name="generated")
+
+# Dicionário global para armazenar sessões de usuários
+# Structure: user_sessions[user_id] = { "jade": [...], "scholar": [...], "heavy": [...] }
+user_sessions = {}
+
+class UserRequest(BaseModel):
+    user_input: str
+    image_base64: str | None = None
+    user_id: str | None = None
+    agent_type: str = "jade" # "jade", "scholar", "heavy"
+    web_search: bool = False  # Toggle para busca web na J.A.D.E.
+
+@app.post("/chat")
+async def handle_chat(request: UserRequest):
+    try:
+        user_id = request.user_id if request.user_id else "default_user"
+        agent_type = request.agent_type.lower()
+        
+        if user_id not in user_sessions:
+            print(f"Nova sessão criada para: {user_id}")
+            user_sessions[user_id] = {
+                "jade": [jade_agent.system_prompt],
+                "scholar": [],
+                "heavy": []
+            }
+        
+        # Ensure sub-keys exist
+        if "jade" not in user_sessions[user_id]: user_sessions[user_id]["jade"] = [jade_agent.system_prompt]
+        if "scholar" not in user_sessions[user_id]: user_sessions[user_id]["scholar"] = []
+        if "heavy" not in user_sessions[user_id]: user_sessions[user_id]["heavy"] = []
+
+        vision_context = None
+        if request.image_base64:
+            try:
+                header, encoded_data = request.image_base64.split(",", 1)
+                image_bytes = base64.b64decode(encoded_data)
+                pil_image = Image.open(io.BytesIO(image_bytes))
+                # Jade handles vision processing
+                vision_context = jade_agent.image_handler.process_pil_image(pil_image)
+            except Exception as img_e:
+                print(f"Erro ao processar imagem Base64: {img_e}")
+                vision_context = "Houve um erro ao analisar a imagem."
+
+        final_user_input = request.user_input if request.user_input else "Descreva a imagem em detalhes."
+
+        bot_response_text = ""
+        audio_path = None
+        
+        if agent_type == "scholar":
+            current_history = user_sessions[user_id]["scholar"]
+            bot_response_text, audio_path, updated_history = scholar_agent.respond(
+                history=current_history,
+                user_input=final_user_input,
+                user_id=user_id,
+                vision_context=vision_context
+            )
+            user_sessions[user_id]["scholar"] = updated_history
+            
+        elif agent_type == "heavy":
+            current_history = user_sessions[user_id]["heavy"]
+            # Heavy agent is async
+            bot_response_text, audio_path, updated_history = await jade_heavy_agent.respond(
+                history=current_history,
+                user_input=final_user_input,
+                user_id=user_id,
+                vision_context=vision_context
+            )
+            user_sessions[user_id]["heavy"] = updated_history
+            
+        else:
+            # Default to J.A.D.E.
+            current_history = user_sessions[user_id]["jade"]
+            # Jade agent is synchronous, run directly
+            bot_response_text, audio_path, updated_history = jade_agent.respond(
+                history=current_history,
+                user_input=final_user_input,
+                user_id=user_id,
+                vision_context=vision_context,
+                web_search=request.web_search  # Passa o toggle de busca web
+            )
+            user_sessions[user_id]["jade"] = updated_history
+
+        # Audio Logic
+        audio_base64 = None
+        if audio_path and os.path.exists(audio_path):
+            print(f"Codificando arquivo de áudio: {audio_path}")
+            with open(audio_path, "rb") as audio_file:
+                audio_bytes = audio_file.read()
+                audio_base64 = base64.b64encode(audio_bytes).decode('utf-8')
+            
+            # Remove only if temp file
+            if "backend/generated" not in audio_path:
+                os.remove(audio_path) 
+        
+        return {
+            "success": True,
+            "bot_response": bot_response_text,
+            "audio_base64": audio_base64 
+        }
+    except Exception as e:
+        print(f"Erro crítico no endpoint /chat: {e}")
+        return {"success": False, "error": str(e)}
+
+@app.get("/")
+def root():
+    return {"message": "Servidor J.A.D.E. com FastAPI está online."}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", 7860))
+    print(f"Iniciando o servidor Uvicorn em http://0.0.0.0:{port}")
+    uvicorn.run(app, host="0.0.0.0", port=port)

gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

jade/config.json

@@ -1,8 +1,8 @@
-{
-  "groq_model": "meta-llama/llama-4-maverick-17b-128e-instruct",
-  "audio_model": "whisper-large-v3",
-  "caption_model": "microsoft/Florence-2-base-ft",
-  "max_context": 12,
-  "language": "pt",
-  "local_mode": false
+{
+  "groq_model": "meta-llama/llama-4-maverick-17b-128e-instruct",
+  "audio_model": "whisper-large-v3",
+  "caption_model": "microsoft/Florence-2-base-ft",
+  "max_context": 12,
+  "language": "pt",
+  "local_mode": false
 }

jade/core.py

@@ -1,139 +1,150 @@
-import json
-import logging
-import os
-import sys
-import time
-import uuid
-
-from groq import Groq
-
-# Importa nossos módulos customizados
-from .handlers import ImageHandler
-from .tts import TTSPlayer
-from .utils import slim_history
-from .shorestone import ShoreStoneMemory
-from .curator_heuristic import MemoryCuratorHeuristic
-
-# Configura o logger principal
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - JADE - %(levelname)s - %(message)s")
-
-class JadeAgent:
-    def __init__(self, config_path="jade/config.json"):
-        # Carrega configurações
-        # Try to load from absolute path first, then relative
-        try:
-            with open(config_path) as f:
-                self.cfg = json.load(f)
-        except FileNotFoundError:
-             # Fallback: try to find it relative to this file
-            base_dir = os.path.dirname(os.path.abspath(__file__))
-            config_path = os.path.join(base_dir, "config.json")
-            with open(config_path) as f:
-                self.cfg = json.load(f)
-
-        # --- Configuração da API Groq ---
-        logging.info("Iniciando J.A.D.E. em modo API (Groq)...")
-        self.api_key = self._get_api_key()
-        self.client = Groq(api_key=self.api_key)
-        self.model_name = self.cfg.get("groq_model", "meta-llama/llama-4-maverick-17b-128e-instruct")
-
-        # System Prompt Base
-        self.system_prompt = {"role": "system", "content": "Você é J.A.D.E., uma IA multimodal calma e inteligente. Seja direta. Responda de forma concisa e natural. NÃO explique seu processo de pensamento. Apenas responda à pergunta."}
-        
-        # --- Inicialização dos Módulos ---
-        logging.info("Carregando módulos de percepção e memória...")
-        
-        # Visão e Fala
-        self.image_handler = ImageHandler(self.cfg.get("caption_model", "Salesforce/blip-image-captioning-large"))
-        self.tts = TTSPlayer(lang=self.cfg.get("language", "pt"))
-        
-        # 1. Memória ShoreStone (Persistente)
-        self.memory = ShoreStoneMemory()
-        # Inicializa com sessão padrão, mas será trocada dinamicamente no respond()
-        self.memory.load_or_create_session("sessao_padrao_gabriel")
-        
-        # 2. Curador Heurístico (Manutenção Automática)
-        self.curator = MemoryCuratorHeuristic(shorestone_memory=self.memory)
-        self.response_count = 0
-        self.maintenance_interval = 10 # Executar a manutenção a cada 10 interações
-
-        logging.info(f"J.A.D.E. pronta e conectada ao modelo {self.model_name}.")
-
-    def _get_api_key(self):
-        """Recupera a chave da API do ambiente de forma segura."""
-        key = os.getenv("GROQ_API_KEY")
-        if not key:
-            logging.error("Chave GROQ_API_KEY não encontrada nas variáveis de ambiente.")
-            # For development, try to warn but not crash if possible, but Groq needs it.
-            # raise RuntimeError("❌ GROQ_API_KEY não encontrada. Defina a variável de ambiente.")
-            print("WARNING: GROQ_API_KEY not found.")
-        return key
-
-    def _chat(self, messages):
-        """Envia as mensagens para a Groq e retorna a resposta."""
-        try:
-            chat = self.client.chat.completions.create(
-                messages=messages, 
-                model=self.model_name,
-                temperature=0.7, # Criatividade balanceada
-                max_tokens=1024  # Limite de resposta razoável
-            )
-            return chat.choices[0].message.content.strip()
-        except Exception as e:
-            logging.error(f"Erro na comunicação com a Groq: {e}")
-            return "Desculpe, tive um problema ao me conectar com meu cérebro na nuvem."
-
-    def respond(self, history, user_input, user_id="default", vision_context=None):
-        """Processo principal de raciocínio: Lembrar -> Ver -> Responder -> Memorizar -> Manter."""
-        
-        # TROCA A SESSÃO DA MEMÓRIA PARA O USUÁRIO ATUAL
-        session_name = f"user_{user_id}"
-        self.memory.load_or_create_session(session_name)
-        
-        messages = history[:]
-        
-        # 1. Lembrar (Recuperação de Contexto)
-        memories = self.memory.remember(user_input)
-        if memories:
-            memory_context = f"--- MEMÓRIAS RELEVANTES (ShoreStone) ---\n{memories}\n--- FIM DAS MEMÓRIAS ---"
-            # Inserimos as memórias como contexto de sistema para guiar a resposta
-            messages.append({"role": "system", "content": memory_context})
-
-        # 2. Ver (Contexto Visual)
-        if vision_context:
-            messages.append({"role": "system", "content": f"Contexto visual da imagem que o usuário enviou: {vision_context}"})
-
-        # Adiciona a pergunta atual ao histórico temporário e ao prompt
-        history.append({"role": "user", "content": user_input})
-        messages.append({"role": "user", "content": user_input})
-
-        # 3. Responder (Geração)
-        resposta = self._chat(messages)
-        
-        # Atualiza histórico
-        history.append({"role": "assistant", "content": resposta})
-        history = slim_history(history, keep=self.cfg.get("max_context", 12))
-        
-        # 4. Memorizar (Armazenamento Persistente)
-        self.memory.memorize(user_input, resposta)
-
-        print(f"\n🤖 J.A.D.E.: {resposta}")
-        
-        # Falar (TTS) - Modified for Backend compatibility
-        audio_path = None
-        try:
-            # Uses the TTSPlayer from tts.py which has save_audio_to_file
-            audio_path = self.tts.save_audio_to_file(resposta)
-        except Exception as e:
-            logging.warning(f"TTS falhou (silenciado): {e}")
-            
-        # 5. Manter (Ciclo de Curadoria Automática)
-        self.response_count += 1
-        if self.response_count % self.maintenance_interval == 0:
-            logging.info(f"Ciclo de manutenção agendado (interação {self.response_count}). Verificando saúde da memória...")
-            try:
-                self.curator.run_maintenance_cycle()
-            except Exception as e:
-                logging.error(f"Erro no Curador de Memória: {e}")
-        
-        return resposta, audio_path, history
+import json
+import logging
+import os
+import sys
+import time
+import uuid
+
+from groq import Groq
+
+# Importa nossos módulos customizados
+from .handlers import ImageHandler
+from .tts import TTSPlayer
+from .utils import slim_history
+from .shorestone import ShoreStoneMemory
+from .curator_heuristic import MemoryCuratorHeuristic
+from .web_search import WebSearchHandler
+
+# Configura o logger principal
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - JADE - %(levelname)s - %(message)s")
+
+class JadeAgent:
+    def __init__(self, config_path="jade/config.json"):
+        # Carrega configurações
+        # Try to load from absolute path first, then relative
+        try:
+            with open(config_path) as f:
+                self.cfg = json.load(f)
+        except FileNotFoundError:
+             # Fallback: try to find it relative to this file
+            base_dir = os.path.dirname(os.path.abspath(__file__))
+            config_path = os.path.join(base_dir, "config.json")
+            with open(config_path) as f:
+                self.cfg = json.load(f)
+
+        # --- Configuração da API Groq ---
+        logging.info("Iniciando J.A.D.E. em modo API (Groq)...")
+        self.api_key = self._get_api_key()
+        self.client = Groq(api_key=self.api_key)
+        self.model_name = self.cfg.get("groq_model", "meta-llama/llama-4-maverick-17b-128e-instruct")
+
+        # System Prompt Base
+        self.system_prompt = {"role": "system", "content": "Você é J.A.D.E., uma IA multimodal calma e inteligente. Seja direta. Responda de forma concisa e natural. NÃO explique seu processo de pensamento. Apenas responda à pergunta."}
+        
+        # --- Inicialização dos Módulos ---
+        logging.info("Carregando módulos de percepção e memória...")
+        
+        # Visão e Fala
+        self.image_handler = ImageHandler(self.cfg.get("caption_model", "Salesforce/blip-image-captioning-large"))
+        self.tts = TTSPlayer(lang=self.cfg.get("language", "pt"))
+        
+        # 1. Memória ShoreStone (Persistente)
+        self.memory = ShoreStoneMemory()
+        # Inicializa com sessão padrão, mas será trocada dinamicamente no respond()
+        self.memory.load_or_create_session("sessao_padrao_gabriel")
+        
+        # 2. Curador Heurístico (Manutenção Automática)
+        self.curator = MemoryCuratorHeuristic(shorestone_memory=self.memory)
+        self.response_count = 0
+        self.maintenance_interval = 10 # Executar a manutenção a cada 10 interações
+
+        # 3. Web Search (Tavily)
+        self.web_search_handler = WebSearchHandler()
+
+        logging.info(f"J.A.D.E. pronta e conectada ao modelo {self.model_name}.")
+
+    def _get_api_key(self):
+        """Recupera a chave da API do ambiente de forma segura."""
+        key = os.getenv("GROQ_API_KEY")
+        if not key:
+            logging.error("Chave GROQ_API_KEY não encontrada nas variáveis de ambiente.")
+            # For development, try to warn but not crash if possible, but Groq needs it.
+            # raise RuntimeError("❌ GROQ_API_KEY não encontrada. Defina a variável de ambiente.")
+            print("WARNING: GROQ_API_KEY not found.")
+        return key
+
+    def _chat(self, messages):
+        """Envia as mensagens para a Groq e retorna a resposta."""
+        try:
+            chat = self.client.chat.completions.create(
+                messages=messages, 
+                model=self.model_name,
+                temperature=0.7, # Criatividade balanceada
+                max_tokens=1024  # Limite de resposta razoável
+            )
+            return chat.choices[0].message.content.strip()
+        except Exception as e:
+            logging.error(f"Erro na comunicação com a Groq: {e}")
+            return "Desculpe, tive um problema ao me conectar com meu cérebro na nuvem."
+
+    def respond(self, history, user_input, user_id="default", vision_context=None, web_search=False):
+        """Processo principal de raciocínio: Buscar -> Lembrar -> Ver -> Responder -> Memorizar -> Manter."""
+        
+        # TROCA A SESSÃO DA MEMÓRIA PARA O USUÁRIO ATUAL
+        session_name = f"user_{user_id}"
+        self.memory.load_or_create_session(session_name)
+        
+        messages = history[:]
+        
+        # 0. Buscar na Web (se habilitado)
+        if web_search and self.web_search_handler.is_available():
+            search_results = self.web_search_handler.search(user_input)
+            if search_results:
+                search_context = f"--- RESULTADOS DA BUSCA WEB ---\n{search_results}\n--- FIM DA BUSCA ---"
+                messages.append({"role": "system", "content": search_context})
+        
+        # 1. Lembrar (Recuperação de Contexto)
+        memories = self.memory.remember(user_input)
+        if memories:
+            memory_context = f"--- MEMÓRIAS RELEVANTES (ShoreStone) ---\n{memories}\n--- FIM DAS MEMÓRIAS ---"
+            # Inserimos as memórias como contexto de sistema para guiar a resposta
+            messages.append({"role": "system", "content": memory_context})
+
+        # 2. Ver (Contexto Visual)
+        if vision_context:
+            messages.append({"role": "system", "content": f"Contexto visual da imagem que o usuário enviou: {vision_context}"})
+
+        # Adiciona a pergunta atual ao histórico temporário e ao prompt
+        history.append({"role": "user", "content": user_input})
+        messages.append({"role": "user", "content": user_input})
+
+        # 3. Responder (Geração)
+        resposta = self._chat(messages)
+        
+        # Atualiza histórico
+        history.append({"role": "assistant", "content": resposta})
+        history = slim_history(history, keep=self.cfg.get("max_context", 12))
+        
+        # 4. Memorizar (Armazenamento Persistente)
+        self.memory.memorize(user_input, resposta)
+
+        print(f"\n🤖 J.A.D.E.: {resposta}")
+        
+        # Falar (TTS) - Modified for Backend compatibility
+        audio_path = None
+        try:
+            # Uses the TTSPlayer from tts.py which has save_audio_to_file
+            audio_path = self.tts.save_audio_to_file(resposta)
+        except Exception as e:
+            logging.warning(f"TTS falhou (silenciado): {e}")
+            
+        # 5. Manter (Ciclo de Curadoria Automática)
+        self.response_count += 1
+        if self.response_count % self.maintenance_interval == 0:
+            logging.info(f"Ciclo de manutenção agendado (interação {self.response_count}). Verificando saúde da memória...")
+            try:
+                self.curator.run_maintenance_cycle()
+            except Exception as e:
+                logging.error(f"Erro no Curador de Memória: {e}")
+        
+        return resposta, audio_path, history

jade/handlers.py

@@ -1,54 +1,54 @@
-from transformers import AutoProcessor, AutoModelForCausalLM
-from PIL import Image
-import torch
-
-class TextHandler:
-    def process(self):
-        return input("⌨️ Digite sua mensagem: ").strip()
-
-class AudioHandler:
-    def __init__(self, client, audio_model):
-        self.client = client
-        self.audio_model = audio_model
-        
-class ImageHandler:
-    def __init__(self, model_name):
-        self.processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True)
-        self.model = AutoModelForCausalLM.from_pretrained(model_name, trust_remote_code=True)
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.model.to(self.device)
-        self.model.eval()
-
-    def process_pil_image(self, pil_image: Image.Image):
-        """Processa um objeto PIL.Image vindo diretamente do Gradio."""
-        if not isinstance(pil_image, Image.Image):
-            raise TypeError("A entrada deve ser um objeto PIL.Image.")
-        return self._generate_caption(pil_image.convert("RGB"))
-
-    def _generate_caption(self, img):
-        """Lógica de geração de legenda reutilizável usando Florence-2."""
-        # Prompt para descrição detalhada
-        prompt = "<MORE_DETAILED_CAPTION>"
-        
-        with torch.no_grad():
-            inputs = self.processor(text=prompt, images=img, return_tensors="pt").to(self.device)
-            
-            generated_ids = self.model.generate(
-                input_ids=inputs["input_ids"],
-                pixel_values=inputs["pixel_values"],
-                max_new_tokens=1024,
-                do_sample=False,
-                num_beams=3,
-            )
-            
-            generated_text = self.processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
-            
-            # O Florence-2 requer pós-processamento para extrair a resposta limpa
-            parsed_answer = self.processor.post_process_generation(
-                generated_text, 
-                task=prompt, 
-                image_size=(img.width, img.height)
-            )
-            
-            # parsed_answer retorna um dict, ex: {'<MORE_DETAILED_CAPTION>': 'texto da legenda'}
-            return parsed_answer.get(prompt, "")
+from transformers import AutoProcessor, AutoModelForCausalLM
+from PIL import Image
+import torch
+
+class TextHandler:
+    def process(self):
+        return input("⌨️ Digite sua mensagem: ").strip()
+
+class AudioHandler:
+    def __init__(self, client, audio_model):
+        self.client = client
+        self.audio_model = audio_model
+        
+class ImageHandler:
+    def __init__(self, model_name):
+        self.processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True)
+        self.model = AutoModelForCausalLM.from_pretrained(model_name, trust_remote_code=True)
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model.to(self.device)
+        self.model.eval()
+
+    def process_pil_image(self, pil_image: Image.Image):
+        """Processa um objeto PIL.Image vindo diretamente do Gradio."""
+        if not isinstance(pil_image, Image.Image):
+            raise TypeError("A entrada deve ser um objeto PIL.Image.")
+        return self._generate_caption(pil_image.convert("RGB"))
+
+    def _generate_caption(self, img):
+        """Lógica de geração de legenda reutilizável usando Florence-2."""
+        # Prompt para descrição detalhada
+        prompt = "<MORE_DETAILED_CAPTION>"
+        
+        with torch.no_grad():
+            inputs = self.processor(text=prompt, images=img, return_tensors="pt").to(self.device)
+            
+            generated_ids = self.model.generate(
+                input_ids=inputs["input_ids"],
+                pixel_values=inputs["pixel_values"],
+                max_new_tokens=1024,
+                do_sample=False,
+                num_beams=3,
+            )
+            
+            generated_text = self.processor.batch_decode(generated_ids, skip_special_tokens=False)[0]
+            
+            # O Florence-2 requer pós-processamento para extrair a resposta limpa
+            parsed_answer = self.processor.post_process_generation(
+                generated_text, 
+                task=prompt, 
+                image_size=(img.width, img.height)
+            )
+            
+            # parsed_answer retorna um dict, ex: {'<MORE_DETAILED_CAPTION>': 'texto da legenda'}
+            return parsed_answer.get(prompt, "")

jade/heavy_mode.py

@@ -1,226 +1,226 @@
-
-import os
-import asyncio
-import random
-import re
-import json
-import logging
-from colorama import Fore, Style
-from groq import AsyncGroq, RateLimitError
-from mistralai import Mistral
-from openai import AsyncOpenAI
-import traceback
-
-# Configura logger local
-logger = logging.getLogger("JadeHeavy")
-logger.setLevel(logging.INFO)
-
-class JadeHeavyAgent:
-    def __init__(self):
-        self.groq_api_key = os.getenv("GROQ_API_KEY")
-        self.mistral_api_key = os.getenv("MISTRAL_API_KEY")
-        self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
-        
-        if not self.groq_api_key:
-            logger.warning("GROQ_API_KEY not set. Jade Heavy may fail.")
-        
-        self.groq_client = AsyncGroq(api_key=self.groq_api_key)
-        
-        self.mistral = None
-        if self.mistral_api_key:
-            self.mistral = Mistral(api_key=self.mistral_api_key)
-        else:
-            logger.warning("MISTRAL_API_KEY not set. Mistral model will be skipped or substituted.")
-
-        self.openrouter = None
-        if self.openrouter_api_key:
-            self.openrouter = AsyncOpenAI(
-                base_url="https://openrouter.ai/api/v1",
-                api_key=self.openrouter_api_key,
-            )
-        else:
-            logger.warning("OPENROUTER_API_KEY not set. Qwen/OpenRouter models will be skipped.")
-
-        # Updated Model Map for Generalist Chat
-        self.models = {
-            "Kimi": "moonshotai/kimi-k2-instruct-0905",      # Groq (Logic/Reasoning)
-            "Mistral": "mistral-large-latest",               # Mistral API
-            "Llama": "openai/gpt-oss-120b", # Groq
-            "Qwen": "qwen/qwen3-coder:free"       # OpenRouter (Fallback if key exists) or Groq equivalent
-            # Note: The original script used qwen/qwen3-235b... on OpenRouter. 
-            # If no OpenRouter key, we might need a fallback on Groq or skip.
-        }
-        
-        # Judge model (Groq is fast and cheap)
-        self.judge_id = "moonshotai/kimi-k2-instruct-0905" 
-
-    async def _safe_propose(self, model_name, history_text):
-        """Phase 1: Strategic Planning"""
-        # Staggering to avoid rate limits
-        delay_map = {"Kimi": 0, "Mistral": 1.0, "Llama": 2.0, "Qwen": 3.0}
-        await asyncio.sleep(delay_map.get(model_name, 1) + random.uniform(0.1, 0.5))
-        
-        sys_prompt = (
-            "You are a Strategic Architect. Create a high-level roadmap to answer the user's request comprehensively.\n"
-            "DO NOT write the final response yet. Just plan the structure and key points.\n"
-            "FORMAT: 1. [INTENT ANALYSIS] 2. [KEY POINTS] 3. [STRUCTURE PROPOSAL]"
-        )
-        
-        messages = [{"role": "system", "content": sys_prompt}, {"role": "user", "content": history_text}]
-
-        try:
-            content = ""
-            if model_name == "Mistral" and self.mistral:
-                resp = await self.mistral.chat.complete_async(model=self.models["Mistral"], messages=messages)
-                content = resp.choices[0].message.content
-            elif model_name == "Qwen" and self.openrouter:
-                 # Use OpenRouter if available
-                resp = await self.openrouter.chat.completions.create(model="qwen/qwen3-235b-a22b:free", messages=messages) # Using the large free one if possible
-                content = resp.choices[0].message.content
-            else:
-                # Default to Groq (Kimi, Llama, or fallback for others)
-                # If Mistral/OpenRouter key missing, fallback to Llama-3-70b on Groq for diversity?
-                target_model = self.models.get(model_name)
-                if not target_model or (model_name == "Mistral" and not self.mistral) or (model_name == "Qwen" and not self.openrouter):
-                     target_model = "openai/gpt-oss-120b" # Fallback
-                
-                resp = await self.groq_client.chat.completions.create(
-                    model=target_model, 
-                    messages=messages, 
-                    temperature=0.7
-                )
-                content = resp.choices[0].message.content
-                
-            if content:
-                return f"--- {model_name} Plan ---\n{content}"
-        except Exception as e:
-            logger.error(f"Error in propose ({model_name}): {e}")
-            return ""
-        return ""
-
-    async def _safe_expand(self, model_name, history_text, strategy):
-        """Phase 3: Execution/Expansion"""
-        delay_map = {"Kimi": 0, "Mistral": 1.5, "Llama": 3.0, "Qwen": 4.5}
-        await asyncio.sleep(delay_map.get(model_name, 1))
-        
-        sys_prompt = (
-            f"You are a Precision Engine. Execute the following plan to answer the user request:\n\n{strategy}\n\n"
-            "Write a detailed, natural, and high-quality response following this plan.\n"
-            "Do not output internal reasoning like '[DECOMPOSITION]', just the final response text."
-        )
-        
-        messages = [{"role": "system", "content": sys_prompt}, {"role": "user", "content": history_text}]
-
-        try:
-            content = ""
-            if model_name == "Mistral" and self.mistral:
-                resp = await self.mistral.chat.complete_async(model=self.models["Mistral"], messages=messages)
-                content = resp.choices[0].message.content
-            elif model_name == "Qwen" and self.openrouter:
-                resp = await self.openrouter.chat.completions.create(model="qwen/qwen3-coder:free", messages=messages)
-                content = resp.choices[0].message.content
-            else:
-                target_model = self.models.get(model_name)
-                if not target_model or (model_name == "Mistral" and not self.mistral) or (model_name == "Qwen" and not self.openrouter):
-                     target_model = "openai/gpt-oss-120b"
-                
-                resp = await self.groq_client.chat.completions.create(
-                    model=target_model, 
-                    messages=messages, 
-                    temperature=0.7
-                )
-                content = resp.choices[0].message.content
-            
-            if content:
-                return f"[{model_name} Draft]:\n{content}"
-        except Exception as e:
-            logger.error(f"Error in expand ({model_name}): {e}")
-            return ""
-        return ""
-
-    async def respond(self, history, user_input, user_id="default", vision_context=None):
-        """
-        Main entry point for the Heavy Agent.
-        History is a list of dicts: [{"role": "user", "content": "..."}...]
-        """
-        
-        # Prepare context
-        full_context = ""
-        for msg in history[-6:]: # Limit context to last few turns to avoid huge prompts
-             full_context += f"{msg['role'].upper()}: {msg['content']}\n"
-        
-        if vision_context:
-            full_context += f"SYSTEM (Vision): {vision_context}\n"
-            
-        full_context += f"USER: {user_input}\n"
-        
-        agents = ["Kimi", "Mistral", "Llama", "Qwen"]
-        
-        # --- PHASE 1: STRATEGY ---
-        logger.info("Jade Heavy: Phase 1 - Planning...")
-        tasks = [self._safe_propose(m, full_context) for m in agents]
-        results = await asyncio.gather(*tasks)
-        valid_strats = [s for s in results if s]
-        
-        if not valid_strats:
-            return "Failed to generate a plan.", None, history
-
-        # --- PHASE 2: PRUNING (Select Best Plan) ---
-        logger.info("Jade Heavy: Phase 2 - Pruning...")
-        prune_prompt = (
-            f"User Request Context:\n{full_context}\n\nProposed Plans:\n" + 
-            "\n".join(valid_strats) + 
-            "\n\nTASK: SELECT THE SINGLE MOST ROBUST AND HELPFUL PLAN. Return ONLY the content of the best plan."
-        )
-        try:
-            best_strat_resp = await self.groq_client.chat.completions.create(
-                model=self.judge_id, 
-                messages=[{"role":"user","content":prune_prompt}], 
-                temperature=0.5
-            )
-            best_strat = best_strat_resp.choices[0].message.content
-        except Exception as e:
-            logger.error(f"Pruning failed: {e}")
-            best_strat = valid_strats[0] # Fallback to first plan
-
-        # --- PHASE 3: EXPANSION (Drafting Responses) ---
-        logger.info("Jade Heavy: Phase 3 - Expansion...")
-        tasks_exp = [self._safe_expand(m, full_context, best_strat) for m in agents]
-        results_exp = await asyncio.gather(*tasks_exp)
-        valid_sols = [s for s in results_exp if s]
-
-        if not valid_sols:
-             return "Failed to generate drafts.", None, history
-
-        # --- PHASE 4: VERDICT (Synthesis) ---
-        logger.info("Jade Heavy: Phase 4 - Verdict...")
-        council_prompt = (
-            f"User Request:\n{full_context}\n\nCandidate Responses:\n" + 
-            "\n".join(valid_sols) + 
-            "\n\nTASK: Synthesize the best parts of these drafts into a FINAL, PERFECT RESPONSE."
-            "The response should be natural, helpful, and high-quality. Do not mention the agents or the process."
-        )
-        
-        final_answer = ""
-        try:
-            resp = await self.groq_client.chat.completions.create(
-                model=self.judge_id, 
-                messages=[{"role":"system","content":"You are the Chief Editor."},{"role":"user","content":council_prompt}], 
-                temperature=0.5
-            )
-            final_answer = resp.choices[0].message.content
-        except Exception as e:
-            logger.error(f"Verdict failed: {e}")
-            final_answer = valid_sols[0].replace(f"[{agents[0]} Draft]:\n", "") # Fallback
-
-        # Update History
-        history.append({"role": "user", "content": user_input})
-        history.append({"role": "assistant", "content": final_answer})
-        
-        # Audio (Optional/Placeholder - returning None for now or use TTS if needed)
-        # The user said "backend focuses on request", so we can skip TTS generation here 
-        # or implement it if JadeAgent does it. The original code uses `jade_agent.tts`.
-        # For Heavy mode, maybe we skip audio for speed, or add it later.
-        # I'll return None for audio path.
-        
-        return final_answer, None, history
+
+import os
+import asyncio
+import random
+import re
+import json
+import logging
+from colorama import Fore, Style
+from groq import AsyncGroq, RateLimitError
+from mistralai import Mistral
+from openai import AsyncOpenAI
+import traceback
+
+# Configura logger local
+logger = logging.getLogger("JadeHeavy")
+logger.setLevel(logging.INFO)
+
+class JadeHeavyAgent:
+    def __init__(self):
+        self.groq_api_key = os.getenv("GROQ_API_KEY")
+        self.mistral_api_key = os.getenv("MISTRAL_API_KEY")
+        self.openrouter_api_key = os.getenv("OPENROUTER_API_KEY")
+        
+        if not self.groq_api_key:
+            logger.warning("GROQ_API_KEY not set. Jade Heavy may fail.")
+        
+        self.groq_client = AsyncGroq(api_key=self.groq_api_key)
+        
+        self.mistral = None
+        if self.mistral_api_key:
+            self.mistral = Mistral(api_key=self.mistral_api_key)
+        else:
+            logger.warning("MISTRAL_API_KEY not set. Mistral model will be skipped or substituted.")
+
+        self.openrouter = None
+        if self.openrouter_api_key:
+            self.openrouter = AsyncOpenAI(
+                base_url="https://openrouter.ai/api/v1",
+                api_key=self.openrouter_api_key,
+            )
+        else:
+            logger.warning("OPENROUTER_API_KEY not set. Qwen/OpenRouter models will be skipped.")
+
+        # Updated Model Map for Generalist Chat
+        self.models = {
+            "Kimi": "moonshotai/kimi-k2-instruct-0905",      # Groq (Logic/Reasoning)
+            "Mistral": "mistral-large-latest",               # Mistral API
+            "Llama": "openai/gpt-oss-120b", # Groq
+            "Qwen": "qwen/qwen3-coder:free"       # OpenRouter (Fallback if key exists) or Groq equivalent
+            # Note: The original script used qwen/qwen3-235b... on OpenRouter. 
+            # If no OpenRouter key, we might need a fallback on Groq or skip.
+        }
+        
+        # Judge model (Groq is fast and cheap)
+        self.judge_id = "moonshotai/kimi-k2-instruct-0905" 
+
+    async def _safe_propose(self, model_name, history_text):
+        """Phase 1: Strategic Planning"""
+        # Staggering to avoid rate limits
+        delay_map = {"Kimi": 0, "Mistral": 1.0, "Llama": 2.0, "Qwen": 3.0}
+        await asyncio.sleep(delay_map.get(model_name, 1) + random.uniform(0.1, 0.5))
+        
+        sys_prompt = (
+            "You are a Strategic Architect. Create a high-level roadmap to answer the user's request comprehensively.\n"
+            "DO NOT write the final response yet. Just plan the structure and key points.\n"
+            "FORMAT: 1. [INTENT ANALYSIS] 2. [KEY POINTS] 3. [STRUCTURE PROPOSAL]"
+        )
+        
+        messages = [{"role": "system", "content": sys_prompt}, {"role": "user", "content": history_text}]
+
+        try:
+            content = ""
+            if model_name == "Mistral" and self.mistral:
+                resp = await self.mistral.chat.complete_async(model=self.models["Mistral"], messages=messages)
+                content = resp.choices[0].message.content
+            elif model_name == "Qwen" and self.openrouter:
+                 # Use OpenRouter if available
+                resp = await self.openrouter.chat.completions.create(model="qwen/qwen3-235b-a22b:free", messages=messages) # Using the large free one if possible
+                content = resp.choices[0].message.content
+            else:
+                # Default to Groq (Kimi, Llama, or fallback for others)
+                # If Mistral/OpenRouter key missing, fallback to Llama-3-70b on Groq for diversity?
+                target_model = self.models.get(model_name)
+                if not target_model or (model_name == "Mistral" and not self.mistral) or (model_name == "Qwen" and not self.openrouter):
+                     target_model = "openai/gpt-oss-120b" # Fallback
+                
+                resp = await self.groq_client.chat.completions.create(
+                    model=target_model, 
+                    messages=messages, 
+                    temperature=0.7
+                )
+                content = resp.choices[0].message.content
+                
+            if content:
+                return f"--- {model_name} Plan ---\n{content}"
+        except Exception as e:
+            logger.error(f"Error in propose ({model_name}): {e}")
+            return ""
+        return ""
+
+    async def _safe_expand(self, model_name, history_text, strategy):
+        """Phase 3: Execution/Expansion"""
+        delay_map = {"Kimi": 0, "Mistral": 1.5, "Llama": 3.0, "Qwen": 4.5}
+        await asyncio.sleep(delay_map.get(model_name, 1))
+        
+        sys_prompt = (
+            f"You are a Precision Engine. Execute the following plan to answer the user request:\n\n{strategy}\n\n"
+            "Write a detailed, natural, and high-quality response following this plan.\n"
+            "Do not output internal reasoning like '[DECOMPOSITION]', just the final response text."
+        )
+        
+        messages = [{"role": "system", "content": sys_prompt}, {"role": "user", "content": history_text}]
+
+        try:
+            content = ""
+            if model_name == "Mistral" and self.mistral:
+                resp = await self.mistral.chat.complete_async(model=self.models["Mistral"], messages=messages)
+                content = resp.choices[0].message.content
+            elif model_name == "Qwen" and self.openrouter:
+                resp = await self.openrouter.chat.completions.create(model="qwen/qwen3-coder:free", messages=messages)
+                content = resp.choices[0].message.content
+            else:
+                target_model = self.models.get(model_name)
+                if not target_model or (model_name == "Mistral" and not self.mistral) or (model_name == "Qwen" and not self.openrouter):
+                     target_model = "openai/gpt-oss-120b"
+                
+                resp = await self.groq_client.chat.completions.create(
+                    model=target_model, 
+                    messages=messages, 
+                    temperature=0.7
+                )
+                content = resp.choices[0].message.content
+            
+            if content:
+                return f"[{model_name} Draft]:\n{content}"
+        except Exception as e:
+            logger.error(f"Error in expand ({model_name}): {e}")
+            return ""
+        return ""
+
+    async def respond(self, history, user_input, user_id="default", vision_context=None):
+        """
+        Main entry point for the Heavy Agent.
+        History is a list of dicts: [{"role": "user", "content": "..."}...]
+        """
+        
+        # Prepare context
+        full_context = ""
+        for msg in history[-6:]: # Limit context to last few turns to avoid huge prompts
+             full_context += f"{msg['role'].upper()}: {msg['content']}\n"
+        
+        if vision_context:
+            full_context += f"SYSTEM (Vision): {vision_context}\n"
+            
+        full_context += f"USER: {user_input}\n"
+        
+        agents = ["Kimi", "Mistral", "Llama", "Qwen"]
+        
+        # --- PHASE 1: STRATEGY ---
+        logger.info("Jade Heavy: Phase 1 - Planning...")
+        tasks = [self._safe_propose(m, full_context) for m in agents]
+        results = await asyncio.gather(*tasks)
+        valid_strats = [s for s in results if s]
+        
+        if not valid_strats:
+            return "Failed to generate a plan.", None, history
+
+        # --- PHASE 2: PRUNING (Select Best Plan) ---
+        logger.info("Jade Heavy: Phase 2 - Pruning...")
+        prune_prompt = (
+            f"User Request Context:\n{full_context}\n\nProposed Plans:\n" + 
+            "\n".join(valid_strats) + 
+            "\n\nTASK: SELECT THE SINGLE MOST ROBUST AND HELPFUL PLAN. Return ONLY the content of the best plan."
+        )
+        try:
+            best_strat_resp = await self.groq_client.chat.completions.create(
+                model=self.judge_id, 
+                messages=[{"role":"user","content":prune_prompt}], 
+                temperature=0.5
+            )
+            best_strat = best_strat_resp.choices[0].message.content
+        except Exception as e:
+            logger.error(f"Pruning failed: {e}")
+            best_strat = valid_strats[0] # Fallback to first plan
+
+        # --- PHASE 3: EXPANSION (Drafting Responses) ---
+        logger.info("Jade Heavy: Phase 3 - Expansion...")
+        tasks_exp = [self._safe_expand(m, full_context, best_strat) for m in agents]
+        results_exp = await asyncio.gather(*tasks_exp)
+        valid_sols = [s for s in results_exp if s]
+
+        if not valid_sols:
+             return "Failed to generate drafts.", None, history
+
+        # --- PHASE 4: VERDICT (Synthesis) ---
+        logger.info("Jade Heavy: Phase 4 - Verdict...")
+        council_prompt = (
+            f"User Request:\n{full_context}\n\nCandidate Responses:\n" + 
+            "\n".join(valid_sols) + 
+            "\n\nTASK: Synthesize the best parts of these drafts into a FINAL, PERFECT RESPONSE."
+            "The response should be natural, helpful, and high-quality. Do not mention the agents or the process."
+        )
+        
+        final_answer = ""
+        try:
+            resp = await self.groq_client.chat.completions.create(
+                model=self.judge_id, 
+                messages=[{"role":"system","content":"You are the Chief Editor."},{"role":"user","content":council_prompt}], 
+                temperature=0.5
+            )
+            final_answer = resp.choices[0].message.content
+        except Exception as e:
+            logger.error(f"Verdict failed: {e}")
+            final_answer = valid_sols[0].replace(f"[{agents[0]} Draft]:\n", "") # Fallback
+
+        # Update History
+        history.append({"role": "user", "content": user_input})
+        history.append({"role": "assistant", "content": final_answer})
+        
+        # Audio (Optional/Placeholder - returning None for now or use TTS if needed)
+        # The user said "backend focuses on request", so we can skip TTS generation here 
+        # or implement it if JadeAgent does it. The original code uses `jade_agent.tts`.
+        # For Heavy mode, maybe we skip audio for speed, or add it later.
+        # I'll return None for audio path.
+        
+        return final_answer, None, history

jade/main.py

@@ -1,8 +1,8 @@
-import os
-import uvicorn
-
-if __name__ == "__main__":
-    port = int(os.environ.get("PORT", 7860))
-    print(f"Iniciando o servidor Uvicorn em http://0.0.0.0:{port}")
-    # Import app from backend.app (module path)
-    uvicorn.run("backend.app:app", host="0.0.0.0", port=port, reload=True)
+import os
+import uvicorn
+
+if __name__ == "__main__":
+    port = int(os.environ.get("PORT", 7860))
+    print(f"Iniciando o servidor Uvicorn em http://0.0.0.0:{port}")
+    # Import app from backend.app (module path)
+    uvicorn.run("backend.app:app", host="0.0.0.0", port=port, reload=True)

jade/scholar.py

@@ -1,584 +1,584 @@
-# backend/jade/scholar.py
-
-import os
-import sys
-import json
-import time
-import re
-import random
-import uuid
-from io import BytesIO
-from typing import List, Dict, Any, Optional
-import numpy as np
-
-# --- 1. Setup e Dependências ---
-# Removido setup_environment() pois será tratado no requirements.txt e Dockerfile
-
-try:
-    import groq
-    import pypdf
-    import faiss
-    import graphviz
-    import genanki
-    from gtts import gTTS
-    from pydub import AudioSegment
-    import requests
-    from bs4 import BeautifulSoup
-    from youtube_transcript_api import YouTubeTranscriptApi
-    from sentence_transformers import SentenceTransformer
-    from fpdf import FPDF
-    from duckduckgo_search import DDGS
-except ImportError:
-    # Em produção, isso deve falhar se as dependências não estiverem instaladas
-    pass
-
-# --- 2. Configuração Global ---
-# Usaremos a configuração passada ou variável de ambiente
-GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-
-# --- 3. Camada de Ferramentas (Tooling Layer) ---
-
-class ToolBox:
-    """Caixa de ferramentas para os agentes."""
-    
-    @staticmethod
-    def read_pdf(filepath: str) -> str:
-        try:
-            print(f"📄 [Ferramenta] Lendo PDF: {filepath}...")
-            reader = pypdf.PdfReader(filepath)
-            text = "".join([p.extract_text() or "" for p in reader.pages])
-            return re.sub(r'\s+', ' ', text).strip()
-        except Exception as e:
-            return f"Erro ao ler PDF: {str(e)}"
-
-    @staticmethod
-    def scrape_web(url: str) -> str:
-        try:
-            print(f"🌐 [Ferramenta] Acessando URL: {url}...")
-            headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
-            response = requests.get(url, headers=headers, timeout=10)
-            soup = BeautifulSoup(response.content, 'html.parser')
-            for script in soup(["script", "style", "header", "footer", "nav"]):
-                script.extract()
-            text = soup.get_text()
-            return re.sub(r'\s+', ' ', text).strip()[:40000]
-        except Exception as e:
-            print(f"Erro ao acessar {url}: {e}")
-            return ""
-
-    @staticmethod
-    def search_topic(topic: str) -> List[str]:
-        """Pesquisa no DuckDuckGo e retorna URLs."""
-        print(f"🔎 [Ferramenta] Pesquisando na Web sobre: '{topic}'...")
-        urls = []
-        try:
-            with DDGS() as ddgs:
-                results = list(ddgs.text(topic, max_results=3))
-                for r in results:
-                    urls.append(r['href'])
-        except Exception as e:
-            print(f"Erro na busca: {e}")
-        return urls
-
-    @staticmethod
-    def get_youtube_transcript(url: str) -> str:
-        try:
-            print(f"📺 [Ferramenta] Extraindo legendas do YouTube: {url}...")
-            video_id = url.split("v=")[-1].split("&")[0]
-            transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['pt', 'en'])
-            text = " ".join([t['text'] for t in transcript])
-            return text
-        except Exception as e:
-            return f"Erro ao pegar legendas do YouTube: {str(e)}"
-
-    @staticmethod
-    def generate_audio_mix(script: List[Dict], filename="aula_podcast.mp3"):
-        print("🎙️ [Estúdio] Produzindo áudio imersivo...")
-        combined = AudioSegment.silent(duration=500)
-        
-        for line in script:
-            speaker = line.get("speaker", "Narrador").upper()
-            text = line.get("text", "")
-            
-            if "BERTA" in speaker or "PROFESSORA" in speaker or "AGENT B" in speaker:
-                tts = gTTS(text=text, lang='pt', tld='pt', slow=False)
-            else:
-                # Gabriel / Agent A
-                tts = gTTS(text=text, lang='pt', tld='com.br', slow=False)
-            
-            fp = BytesIO()
-            tts.write_to_fp(fp)
-            fp.seek(0)
-            
-            try:
-                segment = AudioSegment.from_file(fp, format="mp3")
-                combined += segment
-                combined += AudioSegment.silent(duration=300)
-            except: pass
-
-        output_path = os.path.join("backend/generated", filename)
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        combined.export(output_path, format="mp3")
-        return output_path
-
-    @staticmethod
-    def generate_mindmap_image(dot_code: str, filename="mapa_mental"):
-        try:
-            print("🗺️ [Design] Renderizando Mapa Mental...")
-            clean_dot = dot_code.replace("```dot", "").replace("```", "").strip()
-            
-            # Ensure generated directory exists
-            output_dir = "backend/generated"
-            os.makedirs(output_dir, exist_ok=True)
-            output_path = os.path.join(output_dir, filename)
-            
-            src = graphviz.Source(clean_dot)
-            src.format = 'png'
-            filepath = src.render(output_path, view=False)
-            return filepath
-        except Exception as e:
-            print(f"Erro ao gerar gráfico: {e}")
-            return None
-            
-    @staticmethod
-    def generate_anki_deck(qa_pairs: List[Dict], deck_name="ScholarGraph Deck"):
-        print("🧠 [Anki] Criando arquivo de Flashcards (.apkg)...")
-        try:
-            model_id = random.randrange(1 << 30, 1 << 31)
-            deck_id = random.randrange(1 << 30, 1 << 31)
-            
-            my_model = genanki.Model(
-              model_id,
-              'Simple Model',
-              fields=[{'name': 'Question'}, {'name': 'Answer'}],
-              templates=[{
-                'name': 'Card 1',
-                'qfmt': '{{Question}}',
-                'afmt': '{{FrontSide}}<hr id="answer">{{Answer}}',
-              }]
-            )
-            
-            my_deck = genanki.Deck(deck_id, deck_name)
-            
-            for item in qa_pairs:
-                my_deck.add_note(genanki.Note(
-                  model=my_model,
-                  fields=[item['question'], item['answer']]
-                ))
-            
-            output_dir = "backend/generated"
-            os.makedirs(output_dir, exist_ok=True)
-            filename = os.path.join(output_dir, f"flashcards_{uuid.uuid4().hex[:8]}.apkg")
-            genanki.Package(my_deck).write_to_file(filename)
-            return filename
-        except Exception as e:
-            print(f"Erro ao criar Anki deck: {e}")
-            return None
-
-# --- 4. Vector Store (RAG) ---
-
-class VectorMemory:
-    def __init__(self):
-        print("🧠 [Memória] Inicializando Banco de Vetores (RAG)...")
-        # Modelo leve para embeddings
-        self.model = SentenceTransformer('all-MiniLM-L6-v2')
-        self.index = None
-        self.chunks = []
-    
-    def ingest(self, text: str, chunk_size=500):
-        words = text.split()
-        # Cria chunks sobrepostos para melhor contexto
-        self.chunks = [' '.join(words[i:i+chunk_size]) for i in range(0, len(words), int(chunk_size*0.8))]
-        
-        print(f"🧠 [Memória] Vetorizando {len(self.chunks)} fragmentos...")
-        if not self.chunks: return
-
-        embeddings = self.model.encode(self.chunks)
-        dimension = embeddings.shape[1]
-        self.index = faiss.IndexFlatL2(dimension)
-        self.index.add(np.array(embeddings).astype('float32'))
-        print("🧠 [Memória] Indexação concluída.")
-
-    def retrieve(self, query: str, k=3) -> str:
-        if not self.index: return ""
-        query_vec = self.model.encode([query])
-        D, I = self.index.search(np.array(query_vec).astype('float32'), k)
-        
-        results = [self.chunks[i] for i in I[0] if i < len(self.chunks)]
-        return "\n\n".join(results)
-
-# --- 5. Estado e LLM ---
-
-class GraphState:
-    def __init__(self):
-        self.raw_content: str = ""
-        self.summary: str = ""
-        self.script: List[Dict] = []
-        self.quiz_data: List[Dict] = []
-        self.mindmap_path: str = ""
-        self.flashcards: List[Dict] = []
-        self.current_quiz_question: int = 0
-        self.xp: int = 0
-        self.mode: str = "input" # input, menu, quiz
-
-class LLMEngine:
-    def __init__(self, api_key=None):
-        self.api_key = api_key or os.environ.get("GROQ_API_KEY")
-        self.client = groq.Groq(api_key=self.api_key)
-        self.model = "moonshotai/kimi-k2-instruct-0905"
-    
-    def chat(self, messages: List[Dict], json_mode=False) -> str:
-        try:
-            kwargs = {"messages": messages, "model": self.model, "temperature": 0.8}
-            if json_mode: kwargs["response_format"] = {"type": "json_object"}
-            return self.client.chat.completions.create(**kwargs).choices[0].message.content
-        except Exception as e:
-            return f"Erro na IA: {e}"
-
-# --- 6. Agentes Avançados (GOD MODE) ---
-
-class ResearcherAgent:
-    """Agente que pesquisa na web se o input for um tópico."""
-    def deep_research(self, topic: str) -> str:
-        print(f"🕵️ [Pesquisador] Iniciando Deep Research sobre: {topic}")
-        urls = ToolBox.search_topic(topic)
-        if not urls:
-            return f"Não encontrei informações sobre {topic}."
-            
-        full_text = ""
-        for url in urls:
-            content = ToolBox.scrape_web(url)
-            if content:
-                full_text += f"\n\n--- Fonte: {url} ---\n{content[:10000]}"
-        
-        return full_text
-
-class FlashcardAgent:
-    """Agente focado em memorização (Anki)."""
-    def __init__(self, llm: LLMEngine):
-        self.llm = llm
-
-    def create_deck(self, content: str) -> List[Dict]:
-        print("🃏 [Flashcard] Gerando pares Pergunta-Resposta...")
-        prompt = f"""
-        Crie 10 Flashcards (Pergunta e Resposta) sobre o conteúdo para memorização.
-        SAÍDA JSON: {{ "cards": [ {{ "question": "...", "answer": "..." }} ] }}
-        Conteúdo: {content[:15000]}
-        """
-        try:
-            resp = self.llm.chat([{"role": "user", "content": prompt}], json_mode=True)
-            return json.loads(resp).get("cards", [])
-        except: return []
-
-class IngestAgent:
-    def __init__(self, researcher: ResearcherAgent):
-        self.researcher = researcher
-
-    def process(self, user_input: str) -> str:
-        # Se for arquivo
-        if user_input.lower().endswith(".pdf") and os.path.exists(user_input):
-            return ToolBox.read_pdf(user_input)
-        # Se for URL
-        elif "youtube.com" in user_input or "youtu.be" in user_input:
-            return ToolBox.get_youtube_transcript(user_input)
-        elif user_input.startswith("http"):
-            return ToolBox.scrape_web(user_input)
-        # Se não for URL nem arquivo, assume que é Tópico para Pesquisa
-        else:
-            print("🔍 Entrada detectada como Tópico. Ativando ResearcherAgent...")
-            return self.researcher.deep_research(user_input)
-
-class ProfessorAgent:
-    def __init__(self, llm: LLMEngine):
-        self.llm = llm
-    
-    def summarize(self, full_text: str) -> str:
-        print("🧠 [Professor] Gerando resumo estratégico...")
-        prompt = f"""
-        Você é um Professor Universitário. Crie um resumo estruturado e profundo.
-        Texto: {full_text[:25000]}
-        Formato: # Título / ## Introdução / ## Pontos Chave / ## Conclusão
-        """
-        return self.llm.chat([{"role": "user", "content": prompt}])
-
-class VisualizerAgent:
-    def __init__(self, llm: LLMEngine):
-        self.llm = llm
-        
-    def create_mindmap(self, text: str) -> str:
-        print("🎨 [Visualizador] Projetando Mapa Mental...")
-        prompt = f"""
-        Crie um código GRAPHVIZ (DOT) para um mapa mental deste conteúdo.
-        Use formas coloridas. NÃO explique, apenas dê o código DOT dentro de ```dot ... ```.
-        Texto: {text[:15000]}
-        """
-        response = self.llm.chat([{"role": "user", "content": prompt}])
-        match = re.search(r'```dot(.*?)```', response, re.DOTALL)
-        if match: return match.group(1).strip()
-        return response
-
-class ScriptwriterAgent:
-    def __init__(self, llm: LLMEngine):
-        self.llm = llm
-
-    def create_script(self, content: str, mode="lecture") -> List[Dict]:
-        if mode == "debate":
-            print("🔥 [Roteirista] Criando DEBATE INTENSO...")
-            prompt = f"""
-            Crie um DEBATE acalorado mas intelectual entre dois agentes (8 falas).
-            Personagens: 
-            - AGENT A (Gabriel): A favor / Otimista / Pragmático.
-            - AGENT B (Berta): Contra / Cética / Filosófica.
-            
-            SAÍDA JSON: {{ "dialogue": [ {{"speaker": "Agent A", "text": "..."}}, {{"speaker": "Agent B", "text": "..."}} ] }}
-            Tema Base: {content[:15000]}
-            """
-        else:
-            print("✍️ [Roteirista] Escrevendo roteiro de aula...")
-            prompt = f"""
-            Crie um roteiro de podcast (8 falas).
-            Personagens: GABRIEL (Aluno BR) e BERTA (Professora PT).
-            SAÍDA JSON: {{ "dialogue": [ {{"speaker": "Gabriel", "text": "..."}}, ...] }}
-            Base: {content[:15000]}
-            """
-        
-        try:
-            resp = self.llm.chat([{"role": "user", "content": prompt}], json_mode=True)
-            return json.loads(resp).get("dialogue", [])
-        except: return []
-
-class ExaminerAgent:
-    def __init__(self, llm: LLMEngine):
-        self.llm = llm
-        
-    def generate_quiz(self, content: str) -> List[Dict]:
-        print("📝 [Examinador] Criando Prova Gamificada...")
-        prompt = f"""
-        Crie 5 perguntas de múltipla escolha (Difíceis).
-        SAÍDA JSON: {{ "quiz": [ {{ "question": "...", "options": ["A)..."], "correct_option": "A", "explanation": "..." }} ] }}
-        Base: {content[:15000]}
-        """
-        try:
-            resp = self.llm.chat([{"role": "user", "content": prompt}], json_mode=True)
-            return json.loads(resp).get("quiz", [])
-        except: return []
-
-class PublisherAgent:
-    def create_handout(self, state: GraphState, filename="Apostila_Estudos.pdf"):
-        print("📚 [Editora] Diagramando Apostila PDF...")
-        pdf = FPDF()
-        pdf.add_page()
-        pdf.set_font("Arial", size=12)
-        pdf.set_font("Arial", 'B', 16)
-        pdf.cell(0, 10, "Apostila de Estudos - Scholar Graph", ln=True, align='C')
-        pdf.ln(10)
-        pdf.set_font("Arial", size=11)
-        safe_summary = state.summary.encode('latin-1', 'replace').decode('latin-1')
-        pdf.multi_cell(0, 7, safe_summary)
-        if state.mindmap_path and os.path.exists(state.mindmap_path):
-            pdf.add_page()
-            pdf.image(state.mindmap_path, x=10, y=30, w=190)
-        
-        output_dir = "backend/generated"
-        os.makedirs(output_dir, exist_ok=True)
-        filepath = os.path.join(output_dir, filename)
-        pdf.output(filepath)
-        return filepath
-
-# --- 7. Agent Class wrapper for backend integration ---
-
-class ScholarAgent:
-    def __init__(self):
-        self.user_states = {} # Map user_id to (ScholarGraphGodMode instance or GraphState)
-        self.api_key = os.getenv("GROQ_API_KEY")
-        # Initialize one engine for general use if needed, but we probably need instances per user or shared resources.
-        # We'll create instances per user request if they don't exist? 
-        # Actually, let's keep it simple. We store state per user.
-    
-    def get_or_create_state(self, user_id):
-        if user_id not in self.user_states:
-            self.user_states[user_id] = {
-                "state": GraphState(),
-                "memory": VectorMemory(),
-                "llm": LLMEngine(self.api_key),
-                "researcher": ResearcherAgent(),
-                "ingestor": None, # Will be init with researcher
-                "professor": None,
-                "visualizer": None,
-                "scriptwriter": None,
-                "examiner": None,
-                "flashcarder": None,
-                "publisher": None
-            }
-            # Wiring dependencies
-            u = self.user_states[user_id]
-            u["ingestor"] = IngestAgent(u["researcher"])
-            u["professor"] = ProfessorAgent(u["llm"])
-            u["visualizer"] = VisualizerAgent(u["llm"])
-            u["scriptwriter"] = ScriptwriterAgent(u["llm"])
-            u["examiner"] = ExaminerAgent(u["llm"])
-            u["flashcarder"] = FlashcardAgent(u["llm"])
-            u["publisher"] = PublisherAgent()
-            
-        return self.user_states[user_id]
-
-    def respond(self, history, user_input, user_id="default", vision_context=None):
-        """
-        Adapts the CLI interaction loop to a Request/Response model.
-        """
-        u = self.get_or_create_state(user_id)
-        state = u["state"]
-        
-        # Helper to format menu
-        def get_menu():
-            return (
-                "\n\n🎓 *MENU SCHOLAR GRAPH*\n"
-                "1. 🧠 Resumo Estratégico\n"
-                "2. 🗺️ Mapa Mental Visual\n"
-                "3. 🎧 Podcast (Aula Didática)\n"
-                "4. 🔥 DEBATE IA (Visões Opostas)\n"
-                "5. 🎮 Quiz Gamificado\n"
-                "6. 🃏 Gerar Flashcards (Anki .apkg)\n"
-                "7. 📚 Baixar Apostila Completa\n"
-                "8. 🔄 Novo Tópico\n"
-                "👉 Escolha uma opção (número ou texto):"
-            )
-
-        # Helper for response with optional file
-        response_text = ""
-        audio_path = None
-        
-        # State Machine Logic
-        
-        # 1. Input Mode: Waiting for topic/url/pdf
-        if state.mode == "input":
-            if not user_input.strip():
-                return "Por favor, forneça um tópico, URL ou arquivo PDF para começar.", None, history
-
-            response_text = f"🔄 Processando '{user_input}'... (Isso pode levar alguns segundos)"
-            
-            # Process content
-            content = u["ingestor"].process(user_input)
-            if not content or len(content) < 50:
-                response_text = "❌ Falha ao obter conteúdo suficiente ou tópico não encontrado. Tente novamente."
-                return response_text, None, history
-            
-            state.raw_content = content
-            u["memory"].ingest(content)
-            state.mode = "menu"
-            response_text += "\n✅ Conteúdo processado com sucesso!" + get_menu()
-            
-            # Update history
-            history.append({"role": "user", "content": user_input})
-            history.append({"role": "assistant", "content": response_text})
-            return response_text, None, history
-
-        # 2. Quiz Mode
-        elif state.mode == "quiz":
-            # Check answer
-            current_q = state.quiz_data[state.current_quiz_question]
-            ans = user_input.strip().upper()
-            
-            feedback = ""
-            if ans and ans[0] == current_q['correct_option'][0]:
-                state.xp += 100
-                feedback = f"✨ ACERTOU! +100 XP. (Total: {state.xp})\n"
-            else:
-                feedback = f"💀 Errou... A resposta era {current_q['correct_option']}.\nExplanation: {current_q.get('explanation', '')}\n"
-            
-            state.current_quiz_question += 1
-            
-            if state.current_quiz_question < len(state.quiz_data):
-                # Next Question
-                q = state.quiz_data[state.current_quiz_question]
-                response_text = feedback + f"\n🔹 QUESTÃO {state.current_quiz_question+1}:\n{q['question']}\n" + "\n".join(q['options'])
-            else:
-                # End of Quiz
-                response_text = feedback + f"\n🏆 FIM DO QUIZ! TOTAL DE XP: {state.xp}\n" + get_menu()
-                state.mode = "menu"
-                
-            history.append({"role": "user", "content": user_input})
-            history.append({"role": "assistant", "content": response_text})
-            return response_text, None, history
-
-        # 3. Menu Mode
-        elif state.mode == "menu":
-            opt = user_input.strip()
-            
-            if opt.startswith("1") or "resumo" in opt.lower():
-                state.summary = u["professor"].summarize(state.raw_content)
-                response_text = "📝 *RESUMO ESTRATÉGICO:*\n\n" + state.summary + get_menu()
-                
-            elif opt.startswith("2") or "mapa" in opt.lower():
-                dot = u["visualizer"].create_mindmap(state.raw_content)
-                filename = f"mindmap_{uuid.uuid4().hex[:8]}"
-                path = ToolBox.generate_mindmap_image(dot, filename)
-                if path:
-                    state.mindmap_path = path
-                    # Since we return text and audio only in this signature, we might need a way to send image.
-                    # The current app structure supports sending audio_base64. 
-                    # We might need to hack it to send image link or modify app.py.
-                    # For now, let's return a link relative to backend/generated (assuming static serving)
-                    response_text = f"🗺️ Mapa Mental gerado: [Baixar Imagem](/generated/{os.path.basename(path)})\n" + get_menu()
-                else:
-                    response_text = "❌ Erro ao gerar mapa mental." + get_menu()
-
-            elif opt.startswith("3") or "podcast" in opt.lower():
-                script = u["scriptwriter"].create_script(state.raw_content, mode="lecture")
-                filename = f"podcast_{uuid.uuid4().hex[:8]}.mp3"
-                path = ToolBox.generate_audio_mix(script, filename)
-                audio_path = path # Return this to be played
-                response_text = "🎧 Aqui está o seu Podcast sobre o tema." + get_menu()
-
-            elif opt.startswith("4") or "debate" in opt.lower():
-                script = u["scriptwriter"].create_script(state.raw_content, mode="debate")
-                filename = f"debate_{uuid.uuid4().hex[:8]}.mp3"
-                path = ToolBox.generate_audio_mix(script, filename)
-                audio_path = path
-                response_text = "🔥 Debate gerado com sucesso." + get_menu()
-
-            elif opt.startswith("5") or "quiz" in opt.lower():
-                state.quiz_data = u["examiner"].generate_quiz(state.raw_content)
-                if state.quiz_data:
-                    state.mode = "quiz"
-                    state.current_quiz_question = 0
-                    state.xp = 0
-                    q = state.quiz_data[0]
-                    response_text = f"🎮 *MODO QUIZ INICIADO*\n\n🔹 QUESTÃO 1:\n{q['question']}\n" + "\n".join(q['options'])
-                else:
-                    response_text = "❌ Não foi possível gerar o quiz." + get_menu()
-
-            elif opt.startswith("6") or "flashcard" in opt.lower():
-                cards = u["flashcarder"].create_deck(state.raw_content)
-                if cards:
-                    path = ToolBox.generate_anki_deck(cards)
-                    if path:
-                        response_text = f"✅ Flashcards gerados: [Baixar Deck Anki](/generated/{os.path.basename(path)})" + get_menu()
-                    else:
-                        response_text = "❌ Erro ao salvar arquivo." + get_menu()
-                else:
-                    response_text = "❌ Erro ao gerar flashcards." + get_menu()
-
-            elif opt.startswith("7") or "apostila" in opt.lower():
-                if state.summary:
-                    filename = f"apostila_{uuid.uuid4().hex[:8]}.pdf"
-                    path = u["publisher"].create_handout(state, filename)
-                    response_text = f"📚 Apostila pronta: [Baixar PDF](/generated/{os.path.basename(path)})" + get_menu()
-                else:
-                    response_text = "⚠️ Gere o Resumo (Opção 1) primeiro!" + get_menu()
-            
-            elif opt.startswith("8") or "novo" in opt.lower() or "sair" in opt.lower():
-                state.mode = "input"
-                # Reset state?
-                state.raw_content = ""
-                state.summary = ""
-                response_text = "🔄 Reiniciando... Qual o novo tópico, link ou PDF?"
-            
-            else:
-                response_text = "Opção inválida. Tente novamente.\n" + get_menu()
-
-            history.append({"role": "user", "content": user_input})
-            history.append({"role": "assistant", "content": response_text})
-            return response_text, audio_path, history
-
-        return "Erro de estado.", None, history
+# backend/jade/scholar.py
+
+import os
+import sys
+import json
+import time
+import re
+import random
+import uuid
+from io import BytesIO
+from typing import List, Dict, Any, Optional
+import numpy as np
+
+# --- 1. Setup e Dependências ---
+# Removido setup_environment() pois será tratado no requirements.txt e Dockerfile
+
+try:
+    import groq
+    import pypdf
+    import faiss
+    import graphviz
+    import genanki
+    from gtts import gTTS
+    from pydub import AudioSegment
+    import requests
+    from bs4 import BeautifulSoup
+    from youtube_transcript_api import YouTubeTranscriptApi
+    from sentence_transformers import SentenceTransformer
+    from fpdf import FPDF
+    from duckduckgo_search import DDGS
+except ImportError:
+    # Em produção, isso deve falhar se as dependências não estiverem instaladas
+    pass
+
+# --- 2. Configuração Global ---
+# Usaremos a configuração passada ou variável de ambiente
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+
+# --- 3. Camada de Ferramentas (Tooling Layer) ---
+
+class ToolBox:
+    """Caixa de ferramentas para os agentes."""
+    
+    @staticmethod
+    def read_pdf(filepath: str) -> str:
+        try:
+            print(f"📄 [Ferramenta] Lendo PDF: {filepath}...")
+            reader = pypdf.PdfReader(filepath)
+            text = "".join([p.extract_text() or "" for p in reader.pages])
+            return re.sub(r'\s+', ' ', text).strip()
+        except Exception as e:
+            return f"Erro ao ler PDF: {str(e)}"
+
+    @staticmethod
+    def scrape_web(url: str) -> str:
+        try:
+            print(f"🌐 [Ferramenta] Acessando URL: {url}...")
+            headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
+            response = requests.get(url, headers=headers, timeout=10)
+            soup = BeautifulSoup(response.content, 'html.parser')
+            for script in soup(["script", "style", "header", "footer", "nav"]):
+                script.extract()
+            text = soup.get_text()
+            return re.sub(r'\s+', ' ', text).strip()[:40000]
+        except Exception as e:
+            print(f"Erro ao acessar {url}: {e}")
+            return ""
+
+    @staticmethod
+    def search_topic(topic: str) -> List[str]:
+        """Pesquisa no DuckDuckGo e retorna URLs."""
+        print(f"🔎 [Ferramenta] Pesquisando na Web sobre: '{topic}'...")
+        urls = []
+        try:
+            with DDGS() as ddgs:
+                results = list(ddgs.text(topic, max_results=3))
+                for r in results:
+                    urls.append(r['href'])
+        except Exception as e:
+            print(f"Erro na busca: {e}")
+        return urls
+
+    @staticmethod
+    def get_youtube_transcript(url: str) -> str:
+        try:
+            print(f"📺 [Ferramenta] Extraindo legendas do YouTube: {url}...")
+            video_id = url.split("v=")[-1].split("&")[0]
+            transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=['pt', 'en'])
+            text = " ".join([t['text'] for t in transcript])
+            return text
+        except Exception as e:
+            return f"Erro ao pegar legendas do YouTube: {str(e)}"
+
+    @staticmethod
+    def generate_audio_mix(script: List[Dict], filename="aula_podcast.mp3"):
+        print("🎙️ [Estúdio] Produzindo áudio imersivo...")
+        combined = AudioSegment.silent(duration=500)
+        
+        for line in script:
+            speaker = line.get("speaker", "Narrador").upper()
+            text = line.get("text", "")
+            
+            if "BERTA" in speaker or "PROFESSORA" in speaker or "AGENT B" in speaker:
+                tts = gTTS(text=text, lang='pt', tld='pt', slow=False)
+            else:
+                # Gabriel / Agent A
+                tts = gTTS(text=text, lang='pt', tld='com.br', slow=False)
+            
+            fp = BytesIO()
+            tts.write_to_fp(fp)
+            fp.seek(0)
+            
+            try:
+                segment = AudioSegment.from_file(fp, format="mp3")
+                combined += segment
+                combined += AudioSegment.silent(duration=300)
+            except: pass
+
+        output_path = os.path.join("backend/generated", filename)
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        combined.export(output_path, format="mp3")
+        return output_path
+
+    @staticmethod
+    def generate_mindmap_image(dot_code: str, filename="mapa_mental"):
+        try:
+            print("🗺️ [Design] Renderizando Mapa Mental...")
+            clean_dot = dot_code.replace("```dot", "").replace("```", "").strip()
+            
+            # Ensure generated directory exists
+            output_dir = "backend/generated"
+            os.makedirs(output_dir, exist_ok=True)
+            output_path = os.path.join(output_dir, filename)
+            
+            src = graphviz.Source(clean_dot)
+            src.format = 'png'
+            filepath = src.render(output_path, view=False)
+            return filepath
+        except Exception as e:
+            print(f"Erro ao gerar gráfico: {e}")
+            return None
+            
+    @staticmethod
+    def generate_anki_deck(qa_pairs: List[Dict], deck_name="ScholarGraph Deck"):
+        print("🧠 [Anki] Criando arquivo de Flashcards (.apkg)...")
+        try:
+            model_id = random.randrange(1 << 30, 1 << 31)
+            deck_id = random.randrange(1 << 30, 1 << 31)
+            
+            my_model = genanki.Model(
+              model_id,
+              'Simple Model',
+              fields=[{'name': 'Question'}, {'name': 'Answer'}],
+              templates=[{
+                'name': 'Card 1',
+                'qfmt': '{{Question}}',
+                'afmt': '{{FrontSide}}<hr id="answer">{{Answer}}',
+              }]
+            )
+            
+            my_deck = genanki.Deck(deck_id, deck_name)
+            
+            for item in qa_pairs:
+                my_deck.add_note(genanki.Note(
+                  model=my_model,
+                  fields=[item['question'], item['answer']]
+                ))
+            
+            output_dir = "backend/generated"
+            os.makedirs(output_dir, exist_ok=True)
+            filename = os.path.join(output_dir, f"flashcards_{uuid.uuid4().hex[:8]}.apkg")
+            genanki.Package(my_deck).write_to_file(filename)
+            return filename
+        except Exception as e:
+            print(f"Erro ao criar Anki deck: {e}")
+            return None
+
+# --- 4. Vector Store (RAG) ---
+
+class VectorMemory:
+    def __init__(self):
+        print("🧠 [Memória] Inicializando Banco de Vetores (RAG)...")
+        # Modelo leve para embeddings
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        self.index = None
+        self.chunks = []
+    
+    def ingest(self, text: str, chunk_size=500):
+        words = text.split()
+        # Cria chunks sobrepostos para melhor contexto
+        self.chunks = [' '.join(words[i:i+chunk_size]) for i in range(0, len(words), int(chunk_size*0.8))]
+        
+        print(f"🧠 [Memória] Vetorizando {len(self.chunks)} fragmentos...")
+        if not self.chunks: return
+
+        embeddings = self.model.encode(self.chunks)
+        dimension = embeddings.shape[1]
+        self.index = faiss.IndexFlatL2(dimension)
+        self.index.add(np.array(embeddings).astype('float32'))
+        print("🧠 [Memória] Indexação concluída.")
+
+    def retrieve(self, query: str, k=3) -> str:
+        if not self.index: return ""
+        query_vec = self.model.encode([query])
+        D, I = self.index.search(np.array(query_vec).astype('float32'), k)
+        
+        results = [self.chunks[i] for i in I[0] if i < len(self.chunks)]
+        return "\n\n".join(results)
+
+# --- 5. Estado e LLM ---
+
+class GraphState:
+    def __init__(self):
+        self.raw_content: str = ""
+        self.summary: str = ""
+        self.script: List[Dict] = []
+        self.quiz_data: List[Dict] = []
+        self.mindmap_path: str = ""
+        self.flashcards: List[Dict] = []
+        self.current_quiz_question: int = 0
+        self.xp: int = 0
+        self.mode: str = "input" # input, menu, quiz
+
+class LLMEngine:
+    def __init__(self, api_key=None):
+        self.api_key = api_key or os.environ.get("GROQ_API_KEY")
+        self.client = groq.Groq(api_key=self.api_key)
+        self.model = "moonshotai/kimi-k2-instruct-0905"
+    
+    def chat(self, messages: List[Dict], json_mode=False) -> str:
+        try:
+            kwargs = {"messages": messages, "model": self.model, "temperature": 0.8}
+            if json_mode: kwargs["response_format"] = {"type": "json_object"}
+            return self.client.chat.completions.create(**kwargs).choices[0].message.content
+        except Exception as e:
+            return f"Erro na IA: {e}"
+
+# --- 6. Agentes Avançados (GOD MODE) ---
+
+class ResearcherAgent:
+    """Agente que pesquisa na web se o input for um tópico."""
+    def deep_research(self, topic: str) -> str:
+        print(f"🕵️ [Pesquisador] Iniciando Deep Research sobre: {topic}")
+        urls = ToolBox.search_topic(topic)
+        if not urls:
+            return f"Não encontrei informações sobre {topic}."
+            
+        full_text = ""
+        for url in urls:
+            content = ToolBox.scrape_web(url)
+            if content:
+                full_text += f"\n\n--- Fonte: {url} ---\n{content[:10000]}"
+        
+        return full_text
+
+class FlashcardAgent:
+    """Agente focado em memorização (Anki)."""
+    def __init__(self, llm: LLMEngine):
+        self.llm = llm
+
+    def create_deck(self, content: str) -> List[Dict]:
+        print("🃏 [Flashcard] Gerando pares Pergunta-Resposta...")
+        prompt = f"""
+        Crie 10 Flashcards (Pergunta e Resposta) sobre o conteúdo para memorização.
+        SAÍDA JSON: {{ "cards": [ {{ "question": "...", "answer": "..." }} ] }}
+        Conteúdo: {content[:15000]}
+        """
+        try:
+            resp = self.llm.chat([{"role": "user", "content": prompt}], json_mode=True)
+            return json.loads(resp).get("cards", [])
+        except: return []
+
+class IngestAgent:
+    def __init__(self, researcher: ResearcherAgent):
+        self.researcher = researcher
+
+    def process(self, user_input: str) -> str:
+        # Se for arquivo
+        if user_input.lower().endswith(".pdf") and os.path.exists(user_input):
+            return ToolBox.read_pdf(user_input)
+        # Se for URL
+        elif "youtube.com" in user_input or "youtu.be" in user_input:
+            return ToolBox.get_youtube_transcript(user_input)
+        elif user_input.startswith("http"):
+            return ToolBox.scrape_web(user_input)
+        # Se não for URL nem arquivo, assume que é Tópico para Pesquisa
+        else:
+            print("🔍 Entrada detectada como Tópico. Ativando ResearcherAgent...")
+            return self.researcher.deep_research(user_input)
+
+class ProfessorAgent:
+    def __init__(self, llm: LLMEngine):
+        self.llm = llm
+    
+    def summarize(self, full_text: str) -> str:
+        print("🧠 [Professor] Gerando resumo estratégico...")
+        prompt = f"""
+        Você é um Professor Universitário. Crie um resumo estruturado e profundo.
+        Texto: {full_text[:25000]}
+        Formato: # Título / ## Introdução / ## Pontos Chave / ## Conclusão
+        """
+        return self.llm.chat([{"role": "user", "content": prompt}])
+
+class VisualizerAgent:
+    def __init__(self, llm: LLMEngine):
+        self.llm = llm
+        
+    def create_mindmap(self, text: str) -> str:
+        print("🎨 [Visualizador] Projetando Mapa Mental...")
+        prompt = f"""
+        Crie um código GRAPHVIZ (DOT) para um mapa mental deste conteúdo.
+        Use formas coloridas. NÃO explique, apenas dê o código DOT dentro de ```dot ... ```.
+        Texto: {text[:15000]}
+        """
+        response = self.llm.chat([{"role": "user", "content": prompt}])
+        match = re.search(r'```dot(.*?)```', response, re.DOTALL)
+        if match: return match.group(1).strip()
+        return response
+
+class ScriptwriterAgent:
+    def __init__(self, llm: LLMEngine):
+        self.llm = llm
+
+    def create_script(self, content: str, mode="lecture") -> List[Dict]:
+        if mode == "debate":
+            print("🔥 [Roteirista] Criando DEBATE INTENSO...")
+            prompt = f"""
+            Crie um DEBATE acalorado mas intelectual entre dois agentes (8 falas).
+            Personagens: 
+            - AGENT A (Gabriel): A favor / Otimista / Pragmático.
+            - AGENT B (Berta): Contra / Cética / Filosófica.
+            
+            SAÍDA JSON: {{ "dialogue": [ {{"speaker": "Agent A", "text": "..."}}, {{"speaker": "Agent B", "text": "..."}} ] }}
+            Tema Base: {content[:15000]}
+            """
+        else:
+            print("✍️ [Roteirista] Escrevendo roteiro de aula...")
+            prompt = f"""
+            Crie um roteiro de podcast (8 falas).
+            Personagens: GABRIEL (Aluno BR) e BERTA (Professora PT).
+            SAÍDA JSON: {{ "dialogue": [ {{"speaker": "Gabriel", "text": "..."}}, ...] }}
+            Base: {content[:15000]}
+            """
+        
+        try:
+            resp = self.llm.chat([{"role": "user", "content": prompt}], json_mode=True)
+            return json.loads(resp).get("dialogue", [])
+        except: return []
+
+class ExaminerAgent:
+    def __init__(self, llm: LLMEngine):
+        self.llm = llm
+        
+    def generate_quiz(self, content: str) -> List[Dict]:
+        print("📝 [Examinador] Criando Prova Gamificada...")
+        prompt = f"""
+        Crie 5 perguntas de múltipla escolha (Difíceis).
+        SAÍDA JSON: {{ "quiz": [ {{ "question": "...", "options": ["A)..."], "correct_option": "A", "explanation": "..." }} ] }}
+        Base: {content[:15000]}
+        """
+        try:
+            resp = self.llm.chat([{"role": "user", "content": prompt}], json_mode=True)
+            return json.loads(resp).get("quiz", [])
+        except: return []
+
+class PublisherAgent:
+    def create_handout(self, state: GraphState, filename="Apostila_Estudos.pdf"):
+        print("📚 [Editora] Diagramando Apostila PDF...")
+        pdf = FPDF()
+        pdf.add_page()
+        pdf.set_font("Arial", size=12)
+        pdf.set_font("Arial", 'B', 16)
+        pdf.cell(0, 10, "Apostila de Estudos - Scholar Graph", ln=True, align='C')
+        pdf.ln(10)
+        pdf.set_font("Arial", size=11)
+        safe_summary = state.summary.encode('latin-1', 'replace').decode('latin-1')
+        pdf.multi_cell(0, 7, safe_summary)
+        if state.mindmap_path and os.path.exists(state.mindmap_path):
+            pdf.add_page()
+            pdf.image(state.mindmap_path, x=10, y=30, w=190)
+        
+        output_dir = "backend/generated"
+        os.makedirs(output_dir, exist_ok=True)
+        filepath = os.path.join(output_dir, filename)
+        pdf.output(filepath)
+        return filepath
+
+# --- 7. Agent Class wrapper for backend integration ---
+
+class ScholarAgent:
+    def __init__(self):
+        self.user_states = {} # Map user_id to (ScholarGraphGodMode instance or GraphState)
+        self.api_key = os.getenv("GROQ_API_KEY")
+        # Initialize one engine for general use if needed, but we probably need instances per user or shared resources.
+        # We'll create instances per user request if they don't exist? 
+        # Actually, let's keep it simple. We store state per user.
+    
+    def get_or_create_state(self, user_id):
+        if user_id not in self.user_states:
+            self.user_states[user_id] = {
+                "state": GraphState(),
+                "memory": VectorMemory(),
+                "llm": LLMEngine(self.api_key),
+                "researcher": ResearcherAgent(),
+                "ingestor": None, # Will be init with researcher
+                "professor": None,
+                "visualizer": None,
+                "scriptwriter": None,
+                "examiner": None,
+                "flashcarder": None,
+                "publisher": None
+            }
+            # Wiring dependencies
+            u = self.user_states[user_id]
+            u["ingestor"] = IngestAgent(u["researcher"])
+            u["professor"] = ProfessorAgent(u["llm"])
+            u["visualizer"] = VisualizerAgent(u["llm"])
+            u["scriptwriter"] = ScriptwriterAgent(u["llm"])
+            u["examiner"] = ExaminerAgent(u["llm"])
+            u["flashcarder"] = FlashcardAgent(u["llm"])
+            u["publisher"] = PublisherAgent()
+            
+        return self.user_states[user_id]
+
+    def respond(self, history, user_input, user_id="default", vision_context=None):
+        """
+        Adapts the CLI interaction loop to a Request/Response model.
+        """
+        u = self.get_or_create_state(user_id)
+        state = u["state"]
+        
+        # Helper to format menu
+        def get_menu():
+            return (
+                "\n\n🎓 *MENU SCHOLAR GRAPH*\n"
+                "1. 🧠 Resumo Estratégico\n"
+                "2. 🗺️ Mapa Mental Visual\n"
+                "3. 🎧 Podcast (Aula Didática)\n"
+                "4. 🔥 DEBATE IA (Visões Opostas)\n"
+                "5. 🎮 Quiz Gamificado\n"
+                "6. 🃏 Gerar Flashcards (Anki .apkg)\n"
+                "7. 📚 Baixar Apostila Completa\n"
+                "8. 🔄 Novo Tópico\n"
+                "👉 Escolha uma opção (número ou texto):"
+            )
+
+        # Helper for response with optional file
+        response_text = ""
+        audio_path = None
+        
+        # State Machine Logic
+        
+        # 1. Input Mode: Waiting for topic/url/pdf
+        if state.mode == "input":
+            if not user_input.strip():
+                return "Por favor, forneça um tópico, URL ou arquivo PDF para começar.", None, history
+
+            response_text = f"🔄 Processando '{user_input}'... (Isso pode levar alguns segundos)"
+            
+            # Process content
+            content = u["ingestor"].process(user_input)
+            if not content or len(content) < 50:
+                response_text = "❌ Falha ao obter conteúdo suficiente ou tópico não encontrado. Tente novamente."
+                return response_text, None, history
+            
+            state.raw_content = content
+            u["memory"].ingest(content)
+            state.mode = "menu"
+            response_text += "\n✅ Conteúdo processado com sucesso!" + get_menu()
+            
+            # Update history
+            history.append({"role": "user", "content": user_input})
+            history.append({"role": "assistant", "content": response_text})
+            return response_text, None, history
+
+        # 2. Quiz Mode
+        elif state.mode == "quiz":
+            # Check answer
+            current_q = state.quiz_data[state.current_quiz_question]
+            ans = user_input.strip().upper()
+            
+            feedback = ""
+            if ans and ans[0] == current_q['correct_option'][0]:
+                state.xp += 100
+                feedback = f"✨ ACERTOU! +100 XP. (Total: {state.xp})\n"
+            else:
+                feedback = f"💀 Errou... A resposta era {current_q['correct_option']}.\nExplanation: {current_q.get('explanation', '')}\n"
+            
+            state.current_quiz_question += 1
+            
+            if state.current_quiz_question < len(state.quiz_data):
+                # Next Question
+                q = state.quiz_data[state.current_quiz_question]
+                response_text = feedback + f"\n🔹 QUESTÃO {state.current_quiz_question+1}:\n{q['question']}\n" + "\n".join(q['options'])
+            else:
+                # End of Quiz
+                response_text = feedback + f"\n🏆 FIM DO QUIZ! TOTAL DE XP: {state.xp}\n" + get_menu()
+                state.mode = "menu"
+                
+            history.append({"role": "user", "content": user_input})
+            history.append({"role": "assistant", "content": response_text})
+            return response_text, None, history
+
+        # 3. Menu Mode
+        elif state.mode == "menu":
+            opt = user_input.strip()
+            
+            if opt.startswith("1") or "resumo" in opt.lower():
+                state.summary = u["professor"].summarize(state.raw_content)
+                response_text = "📝 *RESUMO ESTRATÉGICO:*\n\n" + state.summary + get_menu()
+                
+            elif opt.startswith("2") or "mapa" in opt.lower():
+                dot = u["visualizer"].create_mindmap(state.raw_content)
+                filename = f"mindmap_{uuid.uuid4().hex[:8]}"
+                path = ToolBox.generate_mindmap_image(dot, filename)
+                if path:
+                    state.mindmap_path = path
+                    # Since we return text and audio only in this signature, we might need a way to send image.
+                    # The current app structure supports sending audio_base64. 
+                    # We might need to hack it to send image link or modify app.py.
+                    # For now, let's return a link relative to backend/generated (assuming static serving)
+                    response_text = f"🗺️ Mapa Mental gerado: [Baixar Imagem](/generated/{os.path.basename(path)})\n" + get_menu()
+                else:
+                    response_text = "❌ Erro ao gerar mapa mental." + get_menu()
+
+            elif opt.startswith("3") or "podcast" in opt.lower():
+                script = u["scriptwriter"].create_script(state.raw_content, mode="lecture")
+                filename = f"podcast_{uuid.uuid4().hex[:8]}.mp3"
+                path = ToolBox.generate_audio_mix(script, filename)
+                audio_path = path # Return this to be played
+                response_text = "🎧 Aqui está o seu Podcast sobre o tema." + get_menu()
+
+            elif opt.startswith("4") or "debate" in opt.lower():
+                script = u["scriptwriter"].create_script(state.raw_content, mode="debate")
+                filename = f"debate_{uuid.uuid4().hex[:8]}.mp3"
+                path = ToolBox.generate_audio_mix(script, filename)
+                audio_path = path
+                response_text = "🔥 Debate gerado com sucesso." + get_menu()
+
+            elif opt.startswith("5") or "quiz" in opt.lower():
+                state.quiz_data = u["examiner"].generate_quiz(state.raw_content)
+                if state.quiz_data:
+                    state.mode = "quiz"
+                    state.current_quiz_question = 0
+                    state.xp = 0
+                    q = state.quiz_data[0]
+                    response_text = f"🎮 *MODO QUIZ INICIADO*\n\n🔹 QUESTÃO 1:\n{q['question']}\n" + "\n".join(q['options'])
+                else:
+                    response_text = "❌ Não foi possível gerar o quiz." + get_menu()
+
+            elif opt.startswith("6") or "flashcard" in opt.lower():
+                cards = u["flashcarder"].create_deck(state.raw_content)
+                if cards:
+                    path = ToolBox.generate_anki_deck(cards)
+                    if path:
+                        response_text = f"✅ Flashcards gerados: [Baixar Deck Anki](/generated/{os.path.basename(path)})" + get_menu()
+                    else:
+                        response_text = "❌ Erro ao salvar arquivo." + get_menu()
+                else:
+                    response_text = "❌ Erro ao gerar flashcards." + get_menu()
+
+            elif opt.startswith("7") or "apostila" in opt.lower():
+                if state.summary:
+                    filename = f"apostila_{uuid.uuid4().hex[:8]}.pdf"
+                    path = u["publisher"].create_handout(state, filename)
+                    response_text = f"📚 Apostila pronta: [Baixar PDF](/generated/{os.path.basename(path)})" + get_menu()
+                else:
+                    response_text = "⚠️ Gere o Resumo (Opção 1) primeiro!" + get_menu()
+            
+            elif opt.startswith("8") or "novo" in opt.lower() or "sair" in opt.lower():
+                state.mode = "input"
+                # Reset state?
+                state.raw_content = ""
+                state.summary = ""
+                response_text = "🔄 Reiniciando... Qual o novo tópico, link ou PDF?"
+            
+            else:
+                response_text = "Opção inválida. Tente novamente.\n" + get_menu()
+
+            history.append({"role": "user", "content": user_input})
+            history.append({"role": "assistant", "content": response_text})
+            return response_text, audio_path, history
+
+        return "Erro de estado.", None, history

jade/tts.py

@@ -1,26 +1,26 @@
-from gtts import gTTS
-import tempfile
-
-class TTSPlayer:
-    def __init__(self, lang="pt"):
-        self.lang = lang
-
-    def save_audio_to_file(self, text):
-        """
-        Gera o áudio a partir do texto e o salva em um arquivo MP3 temporário.
-        Retorna o caminho (path) para o arquivo de áudio gerado.
-        """
-        try:
-            tts = gTTS(text, lang=self.lang, slow=False)
-            
-            # Cria um arquivo temporário com a extensão .mp3
-            with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as fp:
-                temp_filename = fp.name
-            
-            # Salva o áudio no arquivo temporário
-            tts.save(temp_filename)
-            
-            return temp_filename
-        except Exception as e:
-            print(f"Erro ao gerar arquivo de áudio TTS: {e}")
+from gtts import gTTS
+import tempfile
+
+class TTSPlayer:
+    def __init__(self, lang="pt"):
+        self.lang = lang
+
+    def save_audio_to_file(self, text):
+        """
+        Gera o áudio a partir do texto e o salva em um arquivo MP3 temporário.
+        Retorna o caminho (path) para o arquivo de áudio gerado.
+        """
+        try:
+            tts = gTTS(text, lang=self.lang, slow=False)
+            
+            # Cria um arquivo temporário com a extensão .mp3
+            with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as fp:
+                temp_filename = fp.name
+            
+            # Salva o áudio no arquivo temporário
+            tts.save(temp_filename)
+            
+            return temp_filename
+        except Exception as e:
+            print(f"Erro ao gerar arquivo de áudio TTS: {e}")
             return None

jade/web_search.py

@@ -0,0 +1,77 @@
+# jade/web_search.py - Tavily Web Search Handler
+import os
+import logging
+
+logger = logging.getLogger("JadeWebSearch")
+
+class WebSearchHandler:
+    """Handler para busca web em tempo real usando Tavily API."""
+    
+    def __init__(self):
+        self.api_key = os.getenv("TAVILY_API_KEY")
+        self.client = None
+        
+        if self.api_key:
+            try:
+                from tavily import TavilyClient
+                self.client = TavilyClient(api_key=self.api_key)
+                logger.info("✅ Tavily WebSearch inicializado com sucesso.")
+            except ImportError:
+                logger.warning("⚠️ tavily-python não instalado. Web search desabilitado.")
+        else:
+            logger.warning("⚠️ TAVILY_API_KEY não encontrada. Web search desabilitado.")
+    
+    def search(self, query: str, max_results: int = 3) -> str:
+        """
+        Busca na web e retorna contexto formatado para a IA.
+        
+        Args:
+            query: Termo de busca
+            max_results: Número máximo de resultados
+            
+        Returns:
+            String formatada com os resultados da busca
+        """
+        if not self.client:
+            return ""
+        
+        try:
+            logger.info(f"🔍 [WebSearch] Buscando: '{query}'")
+            
+            response = self.client.search(
+                query=query,
+                search_depth="basic",  # "basic" é mais rápido, "advanced" mais completo
+                max_results=max_results,
+                include_answer=True,  # Tavily já gera um resumo
+                include_raw_content=False  # Não precisamos do HTML cru
+            )
+            
+            # Monta contexto formatado
+            context_parts = []
+            
+            # Resposta resumida do Tavily (se disponível)
+            if response.get("answer"):
+                context_parts.append(f"📝 Resumo: {response['answer']}")
+            
+            # Resultados individuais
+            results = response.get("results", [])
+            if results:
+                context_parts.append("\n📰 Fontes encontradas:")
+                for i, result in enumerate(results[:max_results], 1):
+                    title = result.get("title", "Sem título")
+                    url = result.get("url", "")
+                    content = result.get("content", "")[:500]  # Limita tamanho
+                    context_parts.append(f"\n{i}. **{title}**\n   URL: {url}\n   {content}")
+            
+            context = "\n".join(context_parts)
+            logger.info(f"🔍 [WebSearch] Encontrados {len(results)} resultados.")
+            
+            return context
+            
+        except Exception as e:
+            logger.error(f"❌ Erro na busca Tavily: {e}")
+            return f"Erro ao buscar na web: {str(e)}"
+    
+    def is_available(self) -> bool:
+        """Verifica se o serviço de busca está disponível."""
+        return self.client is not None

requirements.txt

@@ -1,30 +1,31 @@
-groq
-gtts
-transformers==4.45.2
-Pillow
-scipy
-torch
-torchvision
-chromadb
-sentence-transformers
-gradio
-fastapi
-uvicorn[standard]
-joblib
-scikit-learn
-numpy
-einops
-timm
-pypdf
-pydub
-beautifulsoup4
-requests
-fpdf
-youtube_transcript_api
-faiss-cpu
-graphviz
-duckduckgo-search
-genanki
-mistralai
-openai
-colorama
+groq
+gtts
+transformers==4.45.2
+Pillow
+scipy
+torch
+torchvision
+chromadb
+sentence-transformers
+gradio
+fastapi
+uvicorn[standard]
+joblib
+scikit-learn
+numpy
+einops
+timm
+pypdf
+pydub
+beautifulsoup4
+requests
+fpdf
+youtube_transcript_api
+faiss-cpu
+graphviz
+duckduckgo-search
+genanki
+mistralai
+openai
+colorama
+tavily-python