Update app.py

app.py

@@ -1,283 +1,271 @@
 """
-🤖 N8n Assistant - Versão Open Source (GRÁTIS)
+🤖 N8n Assistant - Open Source (GRÁTIS, CPU-friendly)
 - Sem OpenAI
-- LLM: microsoft/Phi-3.5-mini-instruct (fallback flan-t5-base)
-- Embeddings: all-MiniLM-L6-v2 (fallback L3-v2)
-- Compatível com Hugging Face Spaces (CPU)
+- LLM: google/flan-t5-base (fallback flan-t5-small)
+- Embeddings: all-MiniLM-L6-v2 (fallback paraphrase-MiniLM-L3-v2)
+- Baixa dataset Jeice/n8n-docs-v2 e gera documentacao.txt
+- Logs detalhados p/ depuração
 """
 
 import os
-import yaml
 import json
+import yaml
 import logging
-from typing import Optional, Tuple
+from typing import Tuple
 
 import gradio as gr
+from huggingface_hub import snapshot_download
 
-# LlamaIndex (open source stacks)
-from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
+# LlamaIndex
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings, ServiceContext
+from llama_index.core.settings import Settings as LISettings
 from llama_index.embeddings.huggingface import HuggingFaceEmbedding
 from llama_index.llms.huggingface import HuggingFaceLLM
 
-from huggingface_hub import snapshot_download
-
-# ------------------------------------------------------------
+# -------------------------
 # Logging
-# ------------------------------------------------------------
+# -------------------------
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("n8n-assistant")
 
-# ------------------------------------------------------------
-# Configs de modelos (primários + fallbacks)
-# ------------------------------------------------------------
-PRIMARY_LLM = "microsoft/Phi-3.5-mini-instruct"
-FALLBACK_LLM = "google/flan-t5-base"  # muito leve
+# -------------------------
+# Modelos (CPU-friendly)
+# -------------------------
+PRIMARY_LLM = "google/flan-t5-base"
+FALLBACK_LLM = "google/flan-t5-small"
 
 PRIMARY_EMB = "sentence-transformers/all-MiniLM-L6-v2"
 FALLBACK_EMB = "sentence-transformers/paraphrase-MiniLM-L3-v2"
 
-# ------------------------------------------------------------
-# Classe principal
-# ------------------------------------------------------------
+# -------------------------
+# App
+# -------------------------
 class N8nAssistant:
-    """Assistente N8n open-source e funcional"""
-
     def __init__(self):
+        self.docs_dir = None
         self.index = None
         self.query_engine = None
-        self.docs_dir = None
         self.inicializado = False
         self.llm_model_used = None
         self.emb_model_used = None
 
-    # --------- Utilitários de dados ----------
-    def extrair_conteudo_arquivos(self, pasta: str) -> str:
-        """Extrai conteúdo textual dos arquivos .yml/.yaml/.json/.md/.txt"""
-        texto_final = ""
+    # ---------- Dataset ----------
+    def baixar_docs(self) -> bool:
+        """Baixa o dataset com a documentação."""
+        try:
+            logger.info("📥 Baixando dataset Jeice/n8n-docs-v2 ...")
+            self.docs_dir = snapshot_download(
+                repo_id="Jeice/n8n-docs-v2",
+                repo_type="dataset"
+            )
+            logger.info(f"✅ Dataset baixado em: {self.docs_dir}")
+            try:
+                logger.info(f"📂 Itens no diretório raiz do dataset: {os.listdir(self.docs_dir)}")
+                data_path = os.path.join(self.docs_dir, "data")
+                if os.path.isdir(data_path):
+                    logger.info(f"📂 Pasta /data encontrada. Itens: {os.listdir(data_path)}")
+            except Exception as e:
+                logger.warning(f"⚠️ Não consegui listar arquivos do dataset: {e}")
+            return True
+        except Exception as e:
+            logger.error(f"❌ Erro ao baixar dataset: {e}")
+            return False
 
+    # ---------- Consolidação ----------
+    def extrair_conteudo_arquivos(self, pasta: str) -> str:
+        """Varre todas as subpastas e agrega .yml/.yaml/.json/.md/.txt em um único texto."""
+        extensoes = ('.yml', '.yaml', '.json', '.md', '.txt')
+        texto_final = []
         if not os.path.exists(pasta):
-            logger.error(f"❌ Pasta não encontrada: {pasta}")
+            logger.error(f"❌ Pasta não existe: {pasta}")
             return ""
 
+        total_arquivos = 0
         for root, _, files in os.walk(pasta):
+            logger.info(f"🔎 Explorando: {root} | {len(files)} arquivos")
             for file in files:
-                caminho_arquivo = os.path.join(root, file)
+                caminho = os.path.join(root, file)
+                if not file.lower().endswith(extensoes):
+                    continue
+                total_arquivos += 1
                 try:
-                    if file.endswith(('.yml', '.yaml')):
-                        with open(caminho_arquivo, 'r', encoding='utf-8') as f:
+                    if file.lower().endswith(('.yml', '.yaml')):
+                        with open(caminho, 'r', encoding='utf-8') as f:
                             data = yaml.safe_load(f)
-                            texto = yaml.dump(data, allow_unicode=True)
-                            texto_final += f"\n\n### Arquivo: {file}\n{texto}"
-
-                    elif file.endswith('.json'):
-                        with open(caminho_arquivo, 'r', encoding='utf-8') as f:
+                        texto = yaml.dump(data, allow_unicode=True, sort_keys=False)
+                    elif file.lower().endswith('.json'):
+                        with open(caminho, 'r', encoding='utf-8') as f:
                             data = json.load(f)
-                            texto = json.dumps(data, indent=2, ensure_ascii=False)
-                            texto_final += f"\n\n### Arquivo: {file}\n{texto}"
-
-                    elif file.endswith(('.md', '.txt')):
-                        with open(caminho_arquivo, 'r', encoding='utf-8') as f:
+                        texto = json.dumps(data, ensure_ascii=False, indent=2)
+                    else:  # .md / .txt
+                        with open(caminho, 'r', encoding='utf-8', errors='ignore') as f:
                             texto = f.read()
-                            texto_final += f"\n\n### Arquivo: {file}\n{texto}"
 
+                    texto_final.append(f"\n\n### Arquivo: {os.path.relpath(caminho, pasta)}\n{texto}")
                 except Exception as e:
-                    logger.warning(f"⚠️ Erro ao ler {file}: {e}")
-                    continue
+                    logger.warning(f"⚠️ Erro lendo {caminho}: {e}")
 
-        return texto_final
+        logger.info(f"🧾 Total de arquivos agregados: {total_arquivos}")
+        return "".join(texto_final)
 
-    def gerar_documentacao(self, pasta_origem: str) -> bool:
-        """Gera um único arquivo 'documentacao.txt' com todo o conteúdo unificado"""
+    def gerar_documentacao(self) -> bool:
+        """Gera documentacao.txt a partir do dataset (raiz + /data se existir)."""
         try:
-            texto = self.extrair_conteudo_arquivos(pasta_origem)
-            if not texto.strip():
-                logger.warning("⚠️ Nenhum conteúdo encontrado para documentação")
+            if not self.docs_dir:
+                logger.error("❌ docs_dir não definido")
                 return False
 
-            with open("documentacao.txt", 'w', encoding='utf-8') as f:
-                f.write(texto)
+            partes = []
+            # raiz do dataset
+            partes.append(self.extrair_conteudo_arquivos(self.docs_dir))
+            # subpasta /data (comum em datasets do HF)
+            data_path = os.path.join(self.docs_dir, "data")
+            if os.path.isdir(data_path):
+                partes.append(self.extrair_conteudo_arquivos(data_path))
 
-            logger.info("✅ Documentação consolidada em documentacao.txt")
-            return True
+            texto = "\n".join([p for p in partes if p and p.strip()])
+            if not texto.strip():
+                logger.error("❌ Nenhum conteúdo válido encontrado no dataset")
+                return False
 
-        except Exception as e:
-            logger.error(f"❌ Erro ao gerar documentação: {e}")
-            return False
+            with open("documentacao.txt", "w", encoding="utf-8") as f:
+                f.write(texto)
 
-    def baixar_docs(self) -> bool:
-        """Baixa a documentação do HF dataset"""
-        try:
-            logger.info("📥 Baixando documentação do dataset Jeice/n8n-docs-v2 ...")
-            self.docs_dir = snapshot_download(
-                repo_id="Jeice/n8n-docs-v2",
-                repo_type="dataset"
-            )
-            logger.info("✅ Download concluído")
+            # Loga um preview
+            preview = texto[:1500]
+            logger.info(f"📝 documentacao.txt gerado (preview 1500 chars):\n{preview}")
             return True
         except Exception as e:
-            logger.error(f"❌ Erro no download do dataset: {e}")
+            logger.error(f"❌ Erro ao gerar documentacao.txt: {e}")
             return False
 
-    # --------- Configuração de modelos ----------
+    # ---------- Modelos ----------
     def configurar_embeddings(self) -> bool:
-        """Configura embeddings HuggingFace com fallback"""
         for emb in (PRIMARY_EMB, FALLBACK_EMB):
             try:
-                Settings.embed_model = HuggingFaceEmbedding(model_name=emb)
+                LISettings.embed_model = HuggingFaceEmbedding(model_name=emb)
                 self.emb_model_used = emb
-                logger.info(f"✅ Embeddings configurados: {emb}")
+                logger.info(f"✅ Embeddings carregados: {emb}")
                 return True
             except Exception as e:
-                logger.warning(f"⚠️ Falha ao carregar embeddings {emb}: {e}")
-        logger.error("❌ Não foi possível configurar embeddings")
+                logger.warning(f"⚠️ Falhou carregar embeddings {emb}: {e}")
         return False
 
     def configurar_llm(self) -> bool:
-        """Configura LLM HuggingFace com fallback, otimizado para CPU"""
-        # parâmetros neutros/seguros para CPU
         gen_kwargs = {
             "temperature": 0.2,
             "do_sample": True,
             "top_p": 0.9
         }
-        # tentar primário depois fallback
-        for model_name in (PRIMARY_LLM, FALLBACK_LLM):
+        for name in (PRIMARY_LLM, FALLBACK_LLM):
             try:
                 llm = HuggingFaceLLM(
-                    model_name=model_name,
-                    tokenizer_name=model_name,
-                    context_window=4096,
-                    max_new_tokens=512,
+                    model_name=name,
+                    tokenizer_name=name,
+                    context_window=2048,
+                    max_new_tokens=384,   # menor = mais leve em CPU
                     generate_kwargs=gen_kwargs,
-                    # device_map="auto" funciona em CPU/GPU no Space
                     device_map="auto",
-                    model_kwargs={
-                        # dtype padrão (evitar float16 em CPU)
-                        "torch_dtype": "auto"
-                    },
-                    # system_prompt para orientar o estilo de resposta
+                    model_kwargs={"torch_dtype": "auto"},
                     system_prompt=(
                         "Você é um assistente especialista em n8n. "
-                        "Responda sempre em português do Brasil, de forma clara e objetiva, "
+                        "Responda em português do Brasil, de forma clara e objetiva, "
                         "baseado exclusivamente na documentação fornecida. "
                         "Se não souber, diga que não há informações suficientes."
                     ),
                 )
-                Settings.llm = llm
-                self.llm_model_used = model_name
-                logger.info(f"✅ LLM configurado: {model_name}")
+                LISettings.llm = llm
+                self.llm_model_used = name
+                logger.info(f"✅ LLM carregado: {name}")
                 return True
             except Exception as e:
-                logger.warning(f"⚠️ Falha ao carregar LLM {model_name}: {e}")
-
-        logger.error("❌ Não foi possível configurar o LLM")
+                logger.warning(f"⚠️ Falhou carregar LLM {name}: {e}")
         return False
 
-    # --------- Indexação ----------
+    # ---------- Index ----------
     def criar_index(self) -> bool:
-        """Cria o índice vetorial a partir de documentacao.txt"""
         try:
             if not os.path.exists("documentacao.txt"):
-                logger.error("❌ documentacao.txt não encontrado")
+                logger.error("❌ documentacao.txt não existe")
                 return False
 
-            documents = SimpleDirectoryReader(
-                input_files=["documentacao.txt"]
-            ).load_data()
-
-            if not documents:
-                logger.error("❌ Nenhum documento carregado")
+            # Carrega o único arquivo consolidado
+            docs = SimpleDirectoryReader(input_files=["documentacao.txt"]).load_data()
+            if not docs:
+                logger.error("❌ Nenhum documento carregado de documentacao.txt")
+                with open("documentacao.txt", "r", encoding="utf-8") as f:
+                    logger.error("📄 documentacao.txt (trecho): " + f.read()[:1200])
                 return False
 
-            # Criar índice + query engine
-            logger.info("🧠 Criando índice (VectorStoreIndex) ...")
-            self.index = VectorStoreIndex.from_documents(documents)
+            logger.info(f"📚 {len(docs)} documento(s) prontos para indexação")
+            self.index = VectorStoreIndex.from_documents(docs)
             self.query_engine = self.index.as_query_engine()
-            logger.info("✅ Índice criado e query_engine pronto")
+            logger.info("✅ Índice e QueryEngine criados")
             return True
-
         except Exception as e:
             logger.error(f"❌ Erro ao criar índice: {e}")
             return False
 
-    # --------- Orquestração ----------
+    # ---------- Orquestração ----------
     def inicializar(self) -> Tuple[bool, str]:
-        """Pipeline completo de inicialização (open-source)"""
         try:
-            # 1) Baixar docs
             if not self.baixar_docs():
-                return False, "Erro ao baixar a documentação (dataset)"
-
-            # 2) Consolidar documentação
-            if not self.gerar_documentacao(self.docs_dir):
-                return False, "Erro ao processar/consolidar a documentação"
-
-            # 3) Configurar embeddings e LLM (open source)
+                return False, "Erro ao baixar dataset"
+            if not self.gerar_documentacao():
+                return False, "Erro ao gerar documentacao.txt"
             if not self.configurar_embeddings():
                 return False, "Erro ao configurar embeddings"
             if not self.configurar_llm():
                 return False, "Erro ao configurar LLM"
-
-            # 4) Criar índice
             if not self.criar_index():
-                return False, "Erro ao criar o índice"
-
+                return False, "Erro ao criar índice"
             self.inicializado = True
-            return True, (
-                f"Sistema inicializado com sucesso | "
-                f"LLM: {self.llm_model_used} | Embeddings: {self.emb_model_used}"
-            )
-
+            return True, f"Pronto | LLM: {self.llm_model_used} | Emb: {self.emb_model_used}"
         except Exception as e:
             logger.error(f"❌ Erro na inicialização: {e}")
-            return False, f"Erro: {str(e)}"
+            return False, f"Erro na inicialização: {e}"
 
     def responder(self, pergunta: str) -> str:
-        """Executa a consulta no query_engine"""
-        if not pergunta or not pergunta.strip():
+        if not pergunta.strip():
             return "⚠️ Por favor, digite uma pergunta."
-
         if not self.inicializado or not self.query_engine:
             return "❌ Sistema não inicializado. Recarregue a página."
-
         try:
-            logger.info(f"🤔 Pergunta: {pergunta[:120]}...")
-            response = self.query_engine.query(pergunta)
-            return str(response)
+            logger.info(f"🤔 Pergunta: {pergunta[:120]}")
+            resp = self.query_engine.query(pergunta)
+            return str(resp)
         except Exception as e:
-            logger.error(f"❌ Erro ao responder: {e}")
-            return f"❌ Erro ao processar pergunta: {str(e)}"
+            logger.error(f"❌ Erro na resposta: {e}")
+            return f"❌ Erro ao processar a pergunta: {e}"
 
 
-# ------------------------------------------------------------
+# -------------------------
 # Bootstrap
-# ------------------------------------------------------------
-logger.info("🚀 Inicializando N8n Assistant (Open Source)...")
+# -------------------------
+logger.info("🚀 Subindo N8n Assistant (Open Source, CPU)...")
 assistant = N8nAssistant()
-sucesso, mensagem = assistant.inicializar()
-
-if sucesso:
-    logger.info(f"✅ {mensagem}")
+ok, status_msg = assistant.inicializar()
+if ok:
+    logger.info(f"✅ {status_msg}")
 else:
-    logger.error(f"❌ {mensagem}")
+    logger.error(f"❌ {status_msg}")
 
-# ------------------------------------------------------------
+# -------------------------
 # Gradio UI
-# ------------------------------------------------------------
+# -------------------------
 def processar_pergunta(pergunta: str) -> str:
-    if not sucesso:
-        return f"❌ Sistema não inicializado: {mensagem}"
+    if not ok:
+        return f"❌ Sistema não inicializado: {status_msg}"
     return assistant.responder(pergunta)
 
-with gr.Blocks(theme=gr.themes.Soft(), title="N8n Assistant (Open Source)") as demo:
+with gr.Blocks(theme=gr.themes.Soft(), title="N8n Assistant") as demo:
     gr.Markdown(
         f"""
         # 🤖 N8n Assistant (Open Source)
-        Assistente para dúvidas sobre **n8n** baseado na documentação oficial e em modelos **open-source**.
-        **Status:** {'✅ Sistema Pronto' if sucesso else '❌ ' + mensagem}
+        Assistente baseado na documentação oficial do **n8n** (dataset do HF).
+        **Status:** {'✅ ' + status_msg if ok else '❌ ' + status_msg}
         """
     )
-
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### 🤖 N8n Bot")
@@ -285,38 +273,33 @@ with gr.Blocks(theme=gr.themes.Soft(), title="N8n Assistant (Open Source)") as d
             gr.Markdown("## Como posso ajudar você com o n8n?")
             with gr.Row():
                 with gr.Column(scale=3):
-                    input_box = gr.Textbox(
+                    pergunta = gr.Textbox(
                         label="Sua pergunta",
-                        placeholder="Ex: Como criar um workflow no n8n?",
+                        placeholder="Ex: Como configurar um Webhook Trigger no n8n?",
                         lines=3
                     )
-                    with gr.Row():
-                        enviar_btn = gr.Button("🚀 Perguntar", variant="primary")
-                        limpar_btn = gr.Button("🧹 Limpar")
+                    enviar = gr.Button("🚀 Perguntar", variant="primary")
+                    limpar = gr.Button("🧹 Limpar")
                 with gr.Column(scale=4):
-                    output_box = gr.Textbox(
+                    resposta = gr.Textbox(
                         label="Resposta",
-                        placeholder="Sua resposta aparecerá aqui...",
-                        lines=12
+                        placeholder="A resposta aparecerá aqui...",
+                        lines=14
                     )
-
-    with gr.Accordion("💡 Exemplos de Perguntas", open=False):
+    with gr.Accordion("💡 Exemplos", open=False):
         gr.Markdown(
             """
-            - Como criar um workflow no n8n?
-            - Para que serve o node HTTP Request?
-            - Como integrar n8n com Google Sheets?
             - Como configurar webhooks no n8n?
-            - Quais são as melhores práticas para workflows?
+            - Para que serve o node HTTP Request?
+            - Como integrar com Google Sheets?
             - Como debugar erros nos nodes?
-            - Como usar condições nos workflows?
-            - Quais nodes usar para automação de email?
+            - Quais são boas práticas de workflows?
             """
         )
 
-    enviar_btn.click(fn=processar_pergunta, inputs=input_box, outputs=output_box)
-    limpar_btn.click(lambda: ("", ""), None, [input_box, output_box])
-    input_box.submit(fn=processar_pergunta, inputs=input_box, outputs=output_box)
+    enviar.click(fn=processar_pergunta, inputs=pergunta, outputs=resposta)
+    limpar.click(lambda: ("", ""), None, [pergunta, resposta])
+    pergunta.submit(fn=processar_pergunta, inputs=pergunta, outputs=resposta)
 
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)