Upload 14 files

Dockerfile

@@ -1,9 +1,6 @@
 # Usa uma imagem Python leve e moderna
 FROM python:3.10-slim
 
-# Instala dependências do sistema (FFmpeg para áudio, Graphviz para mapas mentais)
-RUN apt-get update && apt-get install -y ffmpeg graphviz && rm -rf /var/lib/apt/lists/*
-
 # Define a pasta de trabalho dentro do container
 WORKDIR /app
 
@@ -22,4 +19,4 @@ RUN mkdir -p /app/jade_memory_db && chmod 777 /app/jade_memory_db
 
 # Comando para ligar o servidor
 # O Hugging Face sempre espera a porta 7860
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -2,15 +2,12 @@
 import os
 import base64
 import io
-import shutil
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse
+from fastapi import FastAPI
 from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel 
 from PIL import Image
-from jade.core import JadeAgent
-from jade.scholar_agent import ScholarAgent
+from jade.core import JadeAgent 
 
 print("Iniciando a J.A.D.E. com FastAPI...")
 agent = JadeAgent() 
@@ -22,34 +19,22 @@ app.add_middleware(
     allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
 )
 
+# Ensure generated directory exists
+GENERATED_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "generated")
+if not os.path.exists(GENERATED_DIR):
+    os.makedirs(GENERATED_DIR)
+
+# Mount static files
+app.mount("/generated", StaticFiles(directory=GENERATED_DIR), name="generated")
+
 # Dicionário global para armazenar sessões de usuários
 user_sessions = {}
-scholar_sessions = {} # Armazena instâncias de ScholarAgent por usuário
 
 class UserRequest(BaseModel):
     user_input: str
     image_base64: str | None = None
     user_id: str | None = None
-
-class ScholarRequest(BaseModel):
-    user_id: str
-    target: str | None = None # URL, Tópico ou Texto
-    action: str | None = None # ingest, summarize, mindmap, podcast, debate, quiz, flashcards, handout
-    mode: str | None = "lecture" # Para podcast/debate
-
-def get_scholar_agent(user_id: str):
-    if user_id not in scholar_sessions:
-        print(f"Criando novo Agente Scholar para: {user_id}")
-        scholar_sessions[user_id] = ScholarAgent()
-    return scholar_sessions[user_id]
-
-def encode_file_base64(filepath):
-    if filepath and os.path.exists(filepath):
-        print(f"Codificando arquivo: {filepath}")
-        with open(filepath, "rb") as f:
-            encoded = base64.b64encode(f.read()).decode('utf-8')
-        return encoded
-    return None
+    agent_mode: str | None = "jade"  # "jade" or "scholar"
 
 @app.post("/chat")
 def handle_chat(request: UserRequest):
@@ -76,127 +61,47 @@ def handle_chat(request: UserRequest):
 
         final_user_input = request.user_input if request.user_input else "Descreva a imagem em detalhes."
 
-        bot_response_text, audio_path, updated_history = agent.respond(
+        # Pass agent_mode to respond
+        bot_response_text, audio_path, updated_history, attachments = agent.respond(
             history=current_history,
             user_input=final_user_input,
             user_id=user_id,
-            vision_context=vision_context
+            vision_context=vision_context,
+            agent_mode=request.agent_mode
         )
         
         # Atualiza o histórico da sessão
         user_sessions[user_id] = updated_history
 
         # LÓGICA DO ÁUDIO: Converte o arquivo MP3 gerado para Base64
+        # Note: If Scholar returns an audio attachment URL, we might still want to return audio_base64 for auto-play?
+        # Or let frontend handle attachments differently.
+        # JadeAgent.respond returns audio_path for TTS. Scholar might return it via attachments.
+        
         audio_base64 = None
         if audio_path and os.path.exists(audio_path):
-            audio_base64 = encode_file_base64(audio_path)
-            os.remove(audio_path) # Limpa arquivo
+            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')
+            # Only remove if it's a temp file. Scholar generated files might persist.
+            # Jade TTS creates temp files. Scholar creates persistent files in /generated.
+            if "/generated/" not in audio_path:
+                os.remove(audio_path) 
         
         return {
             "success": True,
             "bot_response": bot_response_text,
-            "audio_base64": audio_base64 
+            "audio_base64": audio_base64, # Envia o áudio como texto para o front-end
+            "attachments": attachments
         }
     except Exception as e:
         print(f"Erro crítico no endpoint /chat: {e}")
         return {"success": False, "error": str(e)}
 
-@app.post("/scholar")
-def handle_scholar(request: ScholarRequest):
-    try:
-        user_id = request.user_id
-        scholar = get_scholar_agent(user_id)
-        
-        response = {"success": True, "message": "", "data": None, "file_base64": None, "file_type": None}
-        
-        if request.action == "ingest":
-            if not request.target:
-                raise HTTPException(status_code=400, detail="Target is required for ingest.")
-            success = scholar.ingest(request.target)
-            if success:
-                response["message"] = f"Conteúdo sobre '{request.target}' processado com sucesso!"
-            else:
-                response["success"] = False
-                response["message"] = "Falha ao processar conteúdo. Tente outro link ou tópico."
-
-        elif request.action == "summarize":
-            summary = scholar.summarize()
-            response["message"] = "Resumo gerado."
-            response["data"] = summary
-
-        elif request.action == "mindmap":
-            path = scholar.mindmap()
-            if path:
-                response["message"] = "Mapa Mental gerado."
-                response["file_base64"] = encode_file_base64(path)
-                response["file_type"] = "image/png"
-                os.remove(path) # Clean up file
-            else:
-                response["success"] = False
-                response["message"] = "Erro ao gerar Mapa Mental."
-
-        elif request.action == "podcast" or request.action == "debate":
-            mode = "debate" if request.action == "debate" else "lecture"
-            path = scholar.podcast(mode=mode)
-            if path:
-                response["message"] = f"Áudio ({mode}) gerado."
-                response["file_base64"] = encode_file_base64(path)
-                response["file_type"] = "audio/mp3"
-                os.remove(path) # Clean up file
-            else:
-                response["success"] = False
-                response["message"] = "Erro ao gerar áudio."
-
-        elif request.action == "quiz":
-            quiz = scholar.quiz()
-            response["message"] = "Quiz gerado."
-            response["data"] = quiz
-
-        elif request.action == "flashcards":
-            path = scholar.flashcards()
-            if path:
-                response["message"] = "Flashcards (.apkg) gerados."
-                response["file_base64"] = encode_file_base64(path)
-                response["file_type"] = "application/octet-stream"
-                response["filename"] = path # Enviar nome do arquivo para download
-                os.remove(path) # Clean up file
-            else:
-                response["success"] = False
-                response["message"] = "Erro ao gerar Flashcards."
-
-        elif request.action == "handout":
-            path = scholar.handout()
-            if path:
-                response["message"] = "Apostila PDF gerada."
-                response["file_base64"] = encode_file_base64(path)
-                response["file_type"] = "application/pdf"
-                os.remove(path) # Clean up file
-            else:
-                response["success"] = False
-                response["message"] = "Erro ao gerar Apostila (gere o Resumo primeiro)."
-        
-        else:
-            response["success"] = False
-            response["message"] = "Ação inválida."
-
-        return response
-
-    except Exception as e:
-        print(f"Erro no Scholar Agent: {e}")
-        return {"success": False, "error": str(e)}
-
-# Mount frontend directory
-# IMPORTANT: This must be the last route/mount to avoid shadowing API endpoints
-frontend_path = os.path.join(os.path.dirname(__file__), "frontend")
-if os.path.exists(frontend_path):
-    print(f"Montando frontend estático em: {frontend_path}")
-    # Mount at root "/" to serve index.html and assets directly
-    app.mount("/", StaticFiles(directory=frontend_path, html=True), name="frontend")
-else:
-    print(f"⚠️ Frontend não encontrado em: {frontend_path}")
-    @app.get("/")
-    def root():
-        return {"message": "Servidor J.A.D.E. com FastAPI está online. Frontend não encontrado."}
+@app.get("/")
+def root():
+    return {"message": "Servidor J.A.D.E. com FastAPI está online."}
 
 if __name__ == "__main__":
     import uvicorn

jade/core.py

@@ -13,6 +13,7 @@ from .tts import TTSPlayer
 from .utils import slim_history
 from .shorestone import ShoreStoneMemory
 from .curator_heuristic import MemoryCuratorHeuristic
+from .scholar import ScholarAgent  # Import Scholar Agent
 
 # Configura o logger principal
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - JADE - %(levelname)s - %(message)s")
@@ -56,6 +57,14 @@ class JadeAgent:
         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. Scholar Agent
+        try:
+            self.scholar = ScholarAgent(api_key=self.api_key)
+            logging.info("Scholar Agent inicializado com sucesso.")
+        except Exception as e:
+            logging.error(f"Erro ao inicializar Scholar Agent: {e}")
+            self.scholar = None
 
         logging.info(f"J.A.D.E. pronta e conectada ao modelo {self.model_name}.")
 
@@ -83,9 +92,64 @@ class JadeAgent:
             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):
+    def respond(self, history, user_input, user_id="default", vision_context=None, agent_mode="jade"):
         """Processo principal de raciocínio: Lembrar -> Ver -> Responder -> Memorizar -> Manter."""
         
+        # Attachments list to return
+        attachments = []
+        
+        # SCHOLAR AGENT ROUTING
+        if agent_mode == "scholar" and self.scholar:
+            scholar_response = self.scholar.process_request(user_input, user_id)
+            resposta = scholar_response.get("text", "")
+            attachments = scholar_response.get("attachments", [])
+            
+            # Add to history
+            history.append({"role": "user", "content": user_input})
+            history.append({"role": "assistant", "content": resposta})
+            
+            # Check for audio attachment to set as primary audio response for autoplay
+            audio_path = None
+            for att in attachments:
+                if att.get("type") == "audio":
+                    # Attachments have URL /generated/filename.mp3
+                    # We need the full file path for TTSPlayer logic in app.py if we wanted to read bytes
+                    # But app.py logic reads file at `audio_path`.
+                    # So we need to convert URL back to path or change app.py logic.
+                    # App.py expects a file path.
+                    
+                    # Convert /generated/foo.mp3 -> backend/generated/foo.mp3
+                    url = att.get("url", "")
+                    filename = os.path.basename(url)
+                    # We know where generated dir is relative to this file? 
+                    # scholar.py defines generated dir.
+                    # It's better if app.py handles the URL if provided.
+                    
+                    # Hack: app.py expects audio_path to read bytes. 
+                    # Let's reconstruct path for now.
+                    # Assuming cwd is repo root
+                    possible_path = os.path.join("backend", "generated", filename)
+                    if os.path.exists(possible_path):
+                        audio_path = possible_path
+                    else:
+                        # Try absolute
+                        possible_path = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "generated", filename)
+                        if os.path.exists(possible_path):
+                            audio_path = possible_path
+            
+            # If no audio generated by scholar, maybe TTS the text?
+            # Scholar usually generates its own audio for podcasts/debates.
+            # If it's just text response, maybe we should TTS it?
+            if not audio_path and resposta:
+                 try:
+                    audio_path = self.tts.save_audio_to_file(resposta)
+                 except Exception as e:
+                    logging.warning(f"TTS falhou: {e}")
+
+            return resposta, audio_path, history, attachments
+
+        # NORMAL JADE AGENT FLOW
+        
         # 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)
@@ -136,4 +200,4 @@ class JadeAgent:
             except Exception as e:
                 logging.error(f"Erro no Curador de Memória: {e}")
         
-        return resposta, audio_path, history
+        return resposta, audio_path, history, attachments

jade/scholar.py

@@ -0,0 +1,545 @@
+# backend/jade/scholar.py
+import os
+import json
+import re
+import random
+import logging
+from io import BytesIO
+from typing import List, Dict, Any, Optional
+import numpy as np
+
+# Third-party imports
+import groq
+import pypdf
+import faiss
+import graphviz
+import genanki
+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
+from gtts import gTTS
+from pydub import AudioSegment
+
+# Setup logging
+logger = logging.getLogger(__name__)
+
+# Constants
+GENERATED_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "generated")
+if not os.path.exists(GENERATED_DIR):
+    os.makedirs(GENERATED_DIR)
+
+class ToolBox:
+    """Caixa de ferramentas para os agentes."""
+    
+    @staticmethod
+    def get_file_path(filename: str) -> str:
+        return os.path.join(GENERATED_DIR, filename)
+
+    @staticmethod
+    def read_pdf(filepath: str) -> str:
+        try:
+            logger.info(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:
+            logger.info(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:
+            logger.error(f"Erro ao acessar {url}: {e}")
+            return ""
+
+    @staticmethod
+    def search_topic(topic: str) -> List[str]:
+        """Pesquisa no DuckDuckGo e retorna URLs."""
+        logger.info(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:
+            logger.error(f"Erro na busca: {e}")
+        return urls
+
+    @staticmethod
+    def get_youtube_transcript(url: str) -> str:
+        try:
+            logger.info(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"):
+        logger.info("🎙️ [Estúdio] Produzindo áudio imersivo...")
+        combined = AudioSegment.silent(duration=500)
+        
+        for line in script:
+            speaker = line.get("speaker", "Narrador").upper()
+            text = line.get("text", "")
+            
+            lang = 'pt'
+            tld = 'com.br'
+            
+            if "BERTA" in speaker or "PROFESSORA" in speaker or "AGENT B" in speaker:
+                tld = 'pt' # Portuguese accent
+            
+            try:
+                tts = gTTS(text=text, lang=lang, tld=tld, slow=False)
+                fp = BytesIO()
+                tts.write_to_fp(fp)
+                fp.seek(0)
+                
+                segment = AudioSegment.from_file(fp, format="mp3")
+                combined += segment
+                combined += AudioSegment.silent(duration=300)
+            except Exception as e: 
+                logger.error(f"Error generating audio segment: {e}")
+
+        filepath = ToolBox.get_file_path(filename)
+        combined.export(filepath, format="mp3")
+        return filepath
+
+    @staticmethod
+    def generate_mindmap_image(dot_code: str, filename="mapa_mental"):
+        try:
+            logger.info("🗺️ [Design] Renderizando Mapa Mental...")
+            clean_dot = dot_code.replace("```dot", "").replace("```", "").strip()
+            filepath = ToolBox.get_file_path(filename)
+            # Graphviz adds extension automatically, so we remove it from filename if present
+            # But Source.render expects filename without extension if we want exact control or with extension?
+            # actually render(filename=...) saves as filename.format
+            
+            src = graphviz.Source(clean_dot)
+            src.format = 'png'
+            output_path = src.render(filename=filepath, view=False, cleanup=True)
+            return output_path
+        except Exception as e:
+            logger.error(f"Erro ao gerar gráfico: {e}")
+            return None
+            
+    @staticmethod
+    def generate_anki_deck(qa_pairs: List[Dict], deck_name="ScholarGraph Deck"):
+        logger.info("🧠 [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']]
+                ))
+            
+            filename = f"flashcards_{deck_id}.apkg"
+            filepath = ToolBox.get_file_path(filename)
+            genanki.Package(my_deck).write_to_file(filepath)
+            return filepath
+        except Exception as e:
+            logger.error(f"Erro ao criar Anki deck: {e}")
+            return None
+
+class VectorMemory:
+    def __init__(self):
+        logger.info("🧠 [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))]
+        
+        logger.info(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'))
+        logger.info("🧠 [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)
+
+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] = []
+
+class LLMEngine:
+    def __init__(self, api_key: str):
+        self.client = groq.Groq(api_key=api_key)
+        self.model = "llama-3.3-70b-versatile"
+    
+    def chat(self, messages: List[Dict], json_mode=False) -> str:
+        try:
+            kwargs = {"messages": messages, "model": self.model, "temperature": 0.6}
+            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}"
+
+# --- Agentes ---
+
+class ResearcherAgent:
+    def deep_research(self, topic: str) -> str:
+        logger.info(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:
+    def __init__(self, llm: LLMEngine):
+        self.llm = llm
+
+    def create_deck(self, content: str) -> List[Dict]:
+        logger.info("🃏 [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 PDF (assume path local se existir, mas no contexto web pode ser mais complexo)
+        # Aqui vamos simplificar: se for URL ou topico.
+        # Se o backend salvar arquivos de upload, poderiamos passar o path aqui.
+        
+        if user_input.lower().endswith(".pdf") and os.path.exists(user_input):
+            return ToolBox.read_pdf(user_input)
+        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)
+        else:
+            logger.info("🔍 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:
+        logger.info("🧠 [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:
+        logger.info("🎨 [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":
+            logger.info("🔥 [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:
+            logger.info("✍️ [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]:
+        logger.info("📝 [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"):
+        logger.info("📚 [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()
+            # FPDF expects path to image
+            pdf.image(state.mindmap_path, x=10, y=30, w=190)
+        
+        filepath = ToolBox.get_file_path(filename)
+        pdf.output(filepath)
+        return filepath
+
+class ScholarAgent:
+    def __init__(self, api_key: Optional[str] = None):
+        self.api_key = api_key or os.getenv("GROQ_API_KEY")
+        if not self.api_key:
+            raise ValueError("GROQ_API_KEY is required for ScholarAgent")
+            
+        self.llm = LLMEngine(self.api_key)
+        self.memory = VectorMemory()
+        
+        self.researcher = ResearcherAgent()
+        self.ingestor = IngestAgent(self.researcher)
+        
+        self.professor = ProfessorAgent(self.llm)
+        self.visualizer = VisualizerAgent(self.llm)
+        self.scriptwriter = ScriptwriterAgent(self.llm)
+        self.examiner = ExaminerAgent(self.llm)
+        self.flashcarder = FlashcardAgent(self.llm)
+        self.publisher = PublisherAgent()
+        
+        # In a real multi-user app, state should be managed externally or per-session.
+        # For this integration, we'll keep a simple session mapping if needed, 
+        # or just pass state around.
+        self.sessions: Dict[str, GraphState] = {}
+
+    def get_or_create_state(self, user_id: str) -> GraphState:
+        if user_id not in self.sessions:
+            self.sessions[user_id] = GraphState()
+        return self.sessions[user_id]
+
+    def process_request(self, user_input: str, user_id: str = "default") -> Dict[str, Any]:
+        """
+        Process user input and return a dictionary with response text and optional attachments.
+        Structure:
+        {
+            "text": "...",
+            "attachments": [
+                {"type": "image", "url": "...", "title": "..."},
+                {"type": "audio", "url": "...", "title": "..."},
+                {"type": "file", "url": "...", "title": "..."}
+            ]
+        }
+        """
+        state = self.get_or_create_state(user_id)
+        
+        # Simple command parsing logic
+        cmd = user_input.lower().strip()
+        
+        if not state.raw_content and not cmd.startswith("scholar:"):
+            # Assume it's a topic or URL to ingest
+            content = self.ingestor.process(user_input)
+            if not content or len(content) < 50:
+                 return {"text": f"Não consegui encontrar conteúdo suficiente sobre '{user_input}'. Tente ser mais específico ou fornecer uma URL válida."}
+            
+            state.raw_content = content
+            self.memory.ingest(content)
+            
+            return {
+                "text": (
+                    f"🎓 Conteúdo sobre '{user_input}' processado com sucesso!\n\n"
+                    "**Menu Scholar Graph:**\n"
+                    "1. Resumo Estratégico\n"
+                    "2. Mapa Mental\n"
+                    "3. Podcast (Aula)\n"
+                    "4. Debate (Prós/Contras)\n"
+                    "5. Quiz Gamificado\n"
+                    "6. Flashcards (Anki)\n"
+                    "7. Gerar Apostila PDF\n\n"
+                    "Digite o número ou o nome da opção."
+                )
+            }
+
+        # Menu handling
+        if "resumo" in cmd or cmd == "1":
+            state.summary = self.professor.summarize(state.raw_content)
+            return {"text": f"## 📝 Resumo Estratégico\n\n{state.summary}"}
+            
+        elif "mapa" in cmd or "mental" in cmd or cmd == "2":
+            dot = self.visualizer.create_mindmap(state.raw_content)
+            path = ToolBox.generate_mindmap_image(dot)
+            if path:
+                state.mindmap_path = path
+                filename = os.path.basename(path)
+                return {
+                    "text": "Aqui está o mapa mental do conteúdo:",
+                    "attachments": [{
+                        "type": "image", 
+                        "url": f"/generated/{filename}",
+                        "title": "Mapa Mental"
+                    }]
+                }
+            return {"text": "Desculpe, não consegui gerar o mapa mental."}
+            
+        elif "podcast" in cmd or "aula" in cmd or cmd == "3":
+            script = self.scriptwriter.create_script(state.raw_content, mode="lecture")
+            path = ToolBox.generate_audio_mix(script, filename=f"podcast_{user_id}.mp3")
+            filename = os.path.basename(path)
+            return {
+                "text": "🎙️ Aula preparada! Ouça abaixo:",
+                "attachments": [{
+                    "type": "audio",
+                    "url": f"/generated/{filename}",
+                    "title": "Aula Podcast"
+                }]
+            }
+            
+        elif "debate" in cmd or cmd == "4":
+            script = self.scriptwriter.create_script(state.raw_content, mode="debate")
+            path = ToolBox.generate_audio_mix(script, filename=f"debate_{user_id}.mp3")
+            filename = os.path.basename(path)
+            return {
+                "text": "🔥 Debate gerado! Ouça abaixo:",
+                "attachments": [{
+                    "type": "audio",
+                    "url": f"/generated/{filename}",
+                    "title": "Debate Intenso"
+                }]
+            }
+            
+        elif "quiz" in cmd or cmd == "5":
+            quiz = self.examiner.generate_quiz(state.raw_content)
+            state.quiz_data = quiz
+            text = "## 🎮 Quiz Gamificado\n\n"
+            for i, q in enumerate(quiz):
+                text += f"**{i+1}. {q['question']}**\n"
+                for opt in q['options']:
+                    text += f"- {opt}\n"
+                text += f"\n*(Resposta correta: {q['correct_option']})*\n\n"
+            return {"text": text}
+            
+        elif "flashcard" in cmd or "anki" in cmd or cmd == "6":
+            cards = self.flashcarder.create_deck(state.raw_content)
+            if cards:
+                path = ToolBox.generate_anki_deck(cards)
+                filename = os.path.basename(path)
+                return {
+                    "text": "✅ Deck do Anki criado com sucesso!",
+                    "attachments": [{
+                        "type": "file",
+                        "url": f"/generated/{filename}",
+                        "title": "Flashcards.apkg"
+                    }]
+                }
+            return {"text": "Falha ao criar flashcards."}
+            
+        elif "apostila" in cmd or "pdf" in cmd or cmd == "7":
+            if not state.summary:
+                state.summary = self.professor.summarize(state.raw_content)
+            
+            path = self.publisher.create_handout(state)
+            filename = os.path.basename(path)
+            return {
+                "text": "📚 Apostila completa gerada!",
+                "attachments": [{
+                    "type": "file",
+                    "url": f"/generated/{filename}",
+                    "title": "Apostila de Estudos.pdf"
+                }]
+            }
+        
+        elif cmd == "sair" or cmd == "8":
+            # Reset state?
+            self.sessions[user_id] = GraphState()
+            return {"text": "Saindo do modo Scholar. Envie um novo tópico para começar."}
+
+        else:
+            # New topic? Or unrecognized command
+             return {
+                "text": (
+                    "Não entendi o comando. Se quiser iniciar um novo tópico, apenas digite o tema ou URL.\n"
+                    "Se estiver tentando acessar o menu, use os números (1-7)."
+                )
+            }

jade/tests/test_scholar.py

@@ -0,0 +1,88 @@
+
+import unittest
+import os
+import sys
+import shutil
+from unittest.mock import MagicMock, patch
+
+# Mock dependencies that might be heavy or require API keys
+sys.modules['groq'] = MagicMock()
+sys.modules['sentence_transformers'] = MagicMock()
+sys.modules['faiss'] = MagicMock()
+sys.modules['pypdf'] = MagicMock()
+sys.modules['genanki'] = MagicMock()
+sys.modules['youtube_transcript_api'] = MagicMock()
+sys.modules['gtts'] = MagicMock()
+sys.modules['pydub'] = MagicMock()
+sys.modules['graphviz'] = MagicMock()
+sys.modules['duckduckgo_search'] = MagicMock()
+
+# Import after mocking
+from backend.jade.scholar import ScholarAgent, ToolBox, GraphState
+
+class TestScholarAgent(unittest.TestCase):
+    def setUp(self):
+        self.mock_api_key = "test_key"
+        with patch.dict(os.environ, {"GROQ_API_KEY": self.mock_api_key}):
+            self.agent = ScholarAgent(api_key=self.mock_api_key)
+        
+        # Ensure generated dir exists
+        self.generated_dir = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "generated")
+        if not os.path.exists(self.generated_dir):
+            os.makedirs(self.generated_dir)
+
+    def test_initialization(self):
+        self.assertIsNotNone(self.agent)
+        self.assertIsNotNone(self.agent.llm)
+
+    def test_get_or_create_state(self):
+        state = self.agent.get_or_create_state("user1")
+        self.assertIsInstance(state, GraphState)
+        
+        state2 = self.agent.get_or_create_state("user1")
+        self.assertEqual(state, state2)
+        
+        state3 = self.agent.get_or_create_state("user2")
+        self.assertNotEqual(state, state3)
+
+    @patch.object(ToolBox, 'search_topic')
+    @patch.object(ToolBox, 'scrape_web')
+    def test_process_request_new_topic(self, mock_scrape, mock_search):
+        mock_search.return_value = ["http://example.com"]
+        mock_scrape.return_value = "Content about topic"
+        
+        response = self.agent.process_request("Physics", "user1")
+        
+        self.assertIn("text", response)
+        self.assertIn("Conteúdo sobre 'Physics' processado", response["text"])
+        self.assertEqual(self.agent.sessions["user1"].raw_content, "\n\n--- Fonte: http://example.com ---\nContent about topic")
+
+    def test_process_request_menu_command(self):
+        # Setup state
+        state = self.agent.get_or_create_state("user1")
+        state.raw_content = "Some content"
+        
+        # Mock professor summarize
+        self.agent.professor.summarize = MagicMock(return_value="Summary of content")
+        
+        response = self.agent.process_request("1", "user1")
+        
+        self.assertIn("text", response)
+        self.assertIn("Resumo Estratégico", response["text"])
+        self.assertIn("Summary of content", response["text"])
+        self.assertEqual(state.summary, "Summary of content")
+
+    def test_process_request_unknown_command(self):
+        # Set state to simulate that we have content, so it should treat input as command
+        state = self.agent.get_or_create_state("user1")
+        state.raw_content = "Some content"
+        
+        response = self.agent.process_request("unknown command", "user1")
+        self.assertIn("text", response)
+        self.assertIn("Não entendi o comando", response["text"])
+        
+    def tearDown(self):
+        pass
+
+if __name__ == '__main__':
+    unittest.main()