Upload 13 files

Dockerfile

@@ -1,6 +1,9 @@
 # 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
 
@@ -19,4 +22,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,11 +2,15 @@
 import os
 import base64
 import io
-from fastapi import FastAPI
+import shutil
+from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel 
 from PIL import Image
-from jade.core import JadeAgent 
+from jade.core import JadeAgent
+from jade.scholar_agent import ScholarAgent
 
 print("Iniciando a J.A.D.E. com FastAPI...")
 agent = JadeAgent() 
@@ -18,14 +22,50 @@ app.add_middleware(
     allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
 )
 
+# Mount frontend directory
+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}")
+    app.mount("/static", StaticFiles(directory=frontend_path), name="static")
+    
+    @app.get("/")
+    async def read_index():
+        return FileResponse(os.path.join(frontend_path, "index.html"))
+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."}
+
 # 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
+
 @app.post("/chat")
 def handle_chat(request: UserRequest):
     try:
@@ -64,27 +104,104 @@ def handle_chat(request: UserRequest):
         # LÓGICA DO ÁUDIO: Converte o arquivo MP3 gerado para Base64
         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')
-            os.remove(audio_path) # Importante: Limpa o arquivo temporário do servidor
+            audio_base64 = encode_file_base64(audio_path)
+            os.remove(audio_path) # Limpa arquivo
         
         return {
             "success": True,
             "bot_response": bot_response_text,
-            "audio_base64": audio_base64 # Envia o áudio como texto para o front-end
+            "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."}
+@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)}
 
 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)
+    uvicorn.run(app, host="0.0.0.0", port=port)

jade/scholar_agent.py

@@ -0,0 +1,438 @@
+# jade/scholar_agent.py
+
+import os
+import sys
+import json
+import time
+import re
+import random
+import logging
+from io import BytesIO
+from typing import List, Dict, Any, Optional
+import numpy as np
+
+# Dependências (Assumindo que estão instaladas via requirements.txt)
+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
+
+# Configuração de Logger
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - SCHOLAR - %(levelname)s - %(message)s")
+
+# --- 1. Ferramentas (ToolBox) ---
+
+class ToolBox:
+    """Caixa de ferramentas para os agentes."""
+    
+    @staticmethod
+    def read_pdf(filepath: str) -> str:
+        try:
+            logging.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:
+            logging.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:
+            logging.error(f"Erro ao acessar {url}: {e}")
+            return ""
+
+    @staticmethod
+    def search_topic(topic: str) -> List[str]:
+        """Pesquisa no DuckDuckGo e retorna URLs."""
+        logging.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:
+            logging.error(f"Erro na busca: {e}")
+        return urls
+
+    @staticmethod
+    def get_youtube_transcript(url: str) -> str:
+        try:
+            logging.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"):
+        logging.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", "")
+            
+            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
+
+        combined.export(filename, format="mp3")
+        return filename
+
+    @staticmethod
+    def generate_mindmap_image(dot_code: str, filename="mapa_mental"):
+        try:
+            logging.info("🗺️ [Design] Renderizando Mapa Mental...")
+            clean_dot = dot_code.replace("```dot", "").replace("```", "").strip()
+            src = graphviz.Source(clean_dot)
+            src.format = 'png'
+            filepath = src.render(filename, view=False)
+            return filepath
+        except Exception as e:
+            logging.error(f"Erro ao gerar gráfico: {e}")
+            return None
+            
+    @staticmethod
+    def generate_anki_deck(qa_pairs: List[Dict], deck_name="ScholarGraph Deck"):
+        logging.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_{int(time.time())}.apkg"
+            genanki.Package(my_deck).write_to_file(filename)
+            return filename
+        except Exception as e:
+            logging.error(f"Erro ao criar Anki deck: {e}")
+            return None
+
+# --- 2. Vector Store (RAG) ---
+
+class VectorMemory:
+    def __init__(self):
+        logging.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))]
+        
+        logging.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'))
+        logging.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)
+
+# --- 3. 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] = []
+
+class LLMEngine:
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key or os.getenv("GROQ_API_KEY")
+        self.client = groq.Groq(api_key=self.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}"
+
+# --- 4. Agentes ---
+
+class ResearcherAgent:
+    """Agente que pesquisa na web se o input for um tópico."""
+    def deep_research(self, topic: str) -> str:
+        logging.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:
+    """Agente focado em memorização (Anki)."""
+    def __init__(self, llm: LLMEngine):
+        self.llm = llm
+
+    def create_deck(self, content: str) -> List[Dict]:
+        logging.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
+        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:
+            logging.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:
+        logging.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:
+        logging.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":
+            logging.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:
+            logging.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]:
+        logging.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=None):
+        if not filename:
+            filename = f"Apostila_{int(time.time())}.pdf"
+        logging.info(f"📚 [Editora] Diagramando Apostila PDF: {filename}...")
+        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)
+        pdf.output(filename)
+        return filename
+
+# --- 5. Agente Mestre ---
+
+class ScholarAgent:
+    def __init__(self, api_key: str = None):
+        self.state = GraphState()
+        self.memory = VectorMemory()
+        
+        try:
+            self.llm = LLMEngine(api_key=api_key)
+        except: 
+            self.llm = None
+            logging.error("Erro ao inicializar LLM. Verifique a chave de API.")
+        
+        self.researcher = ResearcherAgent()
+        self.ingestor = IngestAgent(self.researcher)
+        
+        if self.llm:
+            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()
+
+    def ingest(self, target: str) -> bool:
+        """Ingere conteúdo de URL, PDF ou tópico de pesquisa."""
+        content = self.ingestor.process(target)
+        if not content or len(content) < 50:
+            logging.error("Falha ao obter conteúdo suficiente.")
+            return False
+            
+        self.state.raw_content = content
+        self.memory.ingest(content)
+        return True
+
+    def summarize(self) -> str:
+        if not self.state.raw_content: return "Sem conteúdo para resumir."
+        self.state.summary = self.professor.summarize(self.state.raw_content)
+        return self.state.summary
+
+    def mindmap(self) -> str:
+        if not self.state.raw_content: return None
+        dot = self.visualizer.create_mindmap(self.state.raw_content)
+        path = ToolBox.generate_mindmap_image(dot)
+        if path:
+            self.state.mindmap_path = path
+        return path
+
+    def podcast(self, mode="lecture") -> str:
+        """Gera podcast ou debate e retorna o caminho do arquivo mp3."""
+        if not self.state.raw_content: return None
+        script = self.scriptwriter.create_script(self.state.raw_content, mode=mode)
+        filename = f"podcast_{mode}_{int(time.time())}.mp3"
+        return ToolBox.generate_audio_mix(script, filename=filename)
+
+    def quiz(self) -> List[Dict]:
+        if not self.state.raw_content: return []
+        self.state.quiz_data = self.examiner.generate_quiz(self.state.raw_content)
+        return self.state.quiz_data
+
+    def flashcards(self) -> str:
+        """Gera flashcards e retorna o caminho do arquivo .apkg."""
+        if not self.state.raw_content: return None
+        cards = self.flashcarder.create_deck(self.state.raw_content)
+        if cards:
+            return ToolBox.generate_anki_deck(cards)
+        return None
+
+    def handout(self) -> str:
+        """Gera apostila PDF e retorna o caminho."""
+        if not self.state.summary:
+            return None # Necessário resumo
+        return self.publisher.create_handout(self.state)

requirements.txt

@@ -14,4 +14,14 @@ joblib
 scikit-learn
 numpy
 einops
-timm
+timm
+pypdf
+pydub
+beautifulsoup4
+requests
+fpdf
+youtube_transcript_api
+faiss-cpu
+graphviz
+duckduckgo-search
+genanki