Update app.py

app.py

@@ -1,72 +1,67 @@
 """
-🤖 N8n Assistant - Versão Corrigida (SEM ERRO DE IMAGEM)
-Chatbot inteligente para dúvidas sobre n8n - Compatível com Hugging Face Spaces
-
-CORREÇÃO APLICADA:
-- Removido componente Image problemático que causava erro 404
-- Mantida toda funcionalidade do sistema
+🤖 N8n Assistant - Versão Open Source (GRÁTIS)
+- 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)
 """
 
 import os
 import yaml
 import json
 import logging
-import time
 from typing import Optional, Tuple
+
 import gradio as gr
 
-# Configurar logging
+# LlamaIndex (open source stacks)
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
+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(__name__)
+logger = logging.getLogger("n8n-assistant")
 
-# Importações com tratamento de erro
-try:
-    from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
-    from llama_index.llms.openai import OpenAI
-    from llama_index.embeddings.openai import OpenAIEmbedding
-    from huggingface_hub import snapshot_download
-    logger.info("✅ Bibliotecas importadas com sucesso")
-except ImportError as e:
-    logger.error(f"❌ Erro ao importar bibliotecas: {e}")
-    raise
+# ------------------------------------------------------------
+# Configs de modelos (primários + fallbacks)
+# ------------------------------------------------------------
+PRIMARY_LLM = "microsoft/Phi-3.5-mini-instruct"
+FALLBACK_LLM = "google/flan-t5-base"  # muito leve
 
+PRIMARY_EMB = "sentence-transformers/all-MiniLM-L6-v2"
+FALLBACK_EMB = "sentence-transformers/paraphrase-MiniLM-L3-v2"
 
+# ------------------------------------------------------------
+# Classe principal
+# ------------------------------------------------------------
 class N8nAssistant:
-    """Assistente N8n simplificado e funcional"""
-    
+    """Assistente N8n open-source e funcional"""
+
     def __init__(self):
         self.index = None
         self.query_engine = None
         self.docs_dir = None
         self.inicializado = False
-        
-    def setup_openai(self) -> bool:
-        """Configurar OpenAI"""
-        try:
-            api_key = os.getenv("OPENAI_API_KEY")
-            if not api_key:
-                logger.error("❌ OPENAI_API_KEY não encontrada")
-                return False
-            
-            os.environ["OPENAI_API_KEY"] = api_key
-            logger.info("✅ OpenAI configurada")
-            return True
-        except Exception as e:
-            logger.error(f"❌ Erro OpenAI: {e}")
-            return False
+        self.llm_model_used = None
+        self.emb_model_used = None
 
+    # --------- Utilitários de dados ----------
     def extrair_conteudo_arquivos(self, pasta: str) -> str:
-        """Extrair conteúdo dos arquivos"""
+        """Extrai conteúdo textual dos arquivos .yml/.yaml/.json/.md/.txt"""
         texto_final = ""
-        
+
         if not os.path.exists(pasta):
             logger.error(f"❌ Pasta não encontrada: {pasta}")
             return ""
 
-        for root, dirs, files in os.walk(pasta):
+        for root, _, files in os.walk(pasta):
             for file in files:
                 caminho_arquivo = os.path.join(root, file)
-                
                 try:
                     if file.endswith(('.yml', '.yaml')):
                         with open(caminho_arquivo, 'r', encoding='utf-8') as f:
@@ -92,28 +87,27 @@ class N8nAssistant:
         return texto_final
 
     def gerar_documentacao(self, pasta_origem: str) -> bool:
-        """Gerar arquivo de documentação"""
+        """Gera um único arquivo 'documentacao.txt' com todo o conteúdo unificado"""
         try:
             texto = self.extrair_conteudo_arquivos(pasta_origem)
-            
             if not texto.strip():
-                logger.warning("⚠️ Nenhum conteúdo encontrado")
+                logger.warning("⚠️ Nenhum conteúdo encontrado para documentação")
                 return False
-            
+
             with open("documentacao.txt", 'w', encoding='utf-8') as f:
                 f.write(texto)
-            
-            logger.info("✅ Documentação gerada")
+
+            logger.info("✅ Documentação consolidada em documentacao.txt")
             return True
-            
+
         except Exception as e:
             logger.error(f"❌ Erro ao gerar documentação: {e}")
             return False
 
     def baixar_docs(self) -> bool:
-        """Baixar documentação do HF"""
+        """Baixa a documentação do HF dataset"""
         try:
-            logger.info("📥 Baixando documentação...")
+            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"
@@ -121,94 +115,144 @@ class N8nAssistant:
             logger.info("✅ Download concluído")
             return True
         except Exception as e:
-            logger.error(f"❌ Erro no download: {e}")
+            logger.error(f"❌ Erro no download do dataset: {e}")
             return False
 
+    # --------- Configuração de 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)
+                self.emb_model_used = emb
+                logger.info(f"✅ Embeddings configurados: {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")
+        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):
+            try:
+                llm = HuggingFaceLLM(
+                    model_name=model_name,
+                    tokenizer_name=model_name,
+                    context_window=4096,
+                    max_new_tokens=512,
+                    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
+                    system_prompt=(
+                        "Você é um assistente especialista em n8n. "
+                        "Responda sempre 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}")
+                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")
+        return False
+
+    # --------- Indexação ----------
     def criar_index(self) -> bool:
-        """Criar índice vetorial"""
+        """Cria o índice vetorial a partir de documentacao.txt"""
         try:
-            # Carregar documentos
             if not os.path.exists("documentacao.txt"):
                 logger.error("❌ documentacao.txt não encontrado")
                 return False
-            
-            documents = SimpleDirectoryReader(input_files=["documentacao.txt"]).load_data()
-            
+
+            documents = SimpleDirectoryReader(
+                input_files=["documentacao.txt"]
+            ).load_data()
+
             if not documents:
                 logger.error("❌ Nenhum documento carregado")
                 return False
-            
-            # Configurar LLM
-            Settings.llm = OpenAI(
-                model="gpt-3.5-turbo",
-                temperature=0.1,
-                system_prompt=(
-                    "Você é um assistente especialista em n8n. "
-                    "Responda sempre 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.embed_model = OpenAIEmbedding()
-            
-            # Criar índice
-            logger.info("🧠 Criando índice...")
+
+            # Criar índice + query engine
+            logger.info("🧠 Criando índice (VectorStoreIndex) ...")
             self.index = VectorStoreIndex.from_documents(documents)
             self.query_engine = self.index.as_query_engine()
-            
-            logger.info("✅ Índice criado")
+            logger.info("✅ Índice criado e query_engine pronto")
             return True
-            
+
         except Exception as e:
             logger.error(f"❌ Erro ao criar índice: {e}")
             return False
 
+    # --------- Orquestração ----------
     def inicializar(self) -> Tuple[bool, str]:
-        """Inicializar sistema completo"""
+        """Pipeline completo de inicialização (open-source)"""
         try:
-            # 1. Configurar OpenAI
-            if not self.setup_openai():
-                return False, "Erro na configuração OpenAI"
-            
-            # 2. Baixar docs
+            # 1) Baixar docs
             if not self.baixar_docs():
-                return False, "Erro no download da documentação"
-            
-            # 3. Gerar documentação
+                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 documentação"
-            
-            # 4. Criar índice
+                return False, "Erro ao processar/consolidar a documentação"
+
+            # 3) Configurar embeddings e LLM (open source)
+            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 índice"
-            
+                return False, "Erro ao criar o índice"
+
             self.inicializado = True
-            return True, "Sistema inicializado com sucesso"
-            
+            return True, (
+                f"Sistema inicializado com sucesso | "
+                f"LLM: {self.llm_model_used} | Embeddings: {self.emb_model_used}"
+            )
+
         except Exception as e:
             logger.error(f"❌ Erro na inicialização: {e}")
             return False, f"Erro: {str(e)}"
 
     def responder(self, pergunta: str) -> str:
-        """Responder pergunta"""
+        """Executa a consulta no query_engine"""
         if not pergunta or 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[:50]}...")
+            logger.info(f"🤔 Pergunta: {pergunta[:120]}...")
             response = self.query_engine.query(pergunta)
             return str(response)
-            
         except Exception as e:
             logger.error(f"❌ Erro ao responder: {e}")
             return f"❌ Erro ao processar pergunta: {str(e)}"
 
 
-# Inicializar sistema
-logger.info("🚀 Inicializando N8n Assistant...")
+# ------------------------------------------------------------
+# Bootstrap
+# ------------------------------------------------------------
+logger.info("🚀 Inicializando N8n Assistant (Open Source)...")
 assistant = N8nAssistant()
 sucesso, mensagem = assistant.inicializar()
 
@@ -217,37 +261,28 @@ if sucesso:
 else:
     logger.error(f"❌ {mensagem}")
 
-
+# ------------------------------------------------------------
+# Gradio UI
+# ------------------------------------------------------------
 def processar_pergunta(pergunta: str) -> str:
-    """Wrapper para Gradio"""
     if not sucesso:
         return f"❌ Sistema não inicializado: {mensagem}"
     return assistant.responder(pergunta)
 
-
-# Interface Gradio - SEM COMPONENTE IMAGE PROBLEMÁTICO
-with gr.Blocks(theme=gr.themes.Soft(), title="N8n Assistant") as demo:
-    
-    # Cabeçalho
+with gr.Blocks(theme=gr.themes.Soft(), title="N8n Assistant (Open Source)") as demo:
     gr.Markdown(
         f"""
-        # 🤖 N8n Assistant
-        
-        Assistente inteligente para dúvidas sobre **n8n** baseado na documentação oficial.
-        
+        # 🤖 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}
         """
-        #**Status:** {'✅ Sistema Pronto' if sucesso else '❌ ' + mensagem}
     )
-    
-    # Layout principal - SEM IMAGEM
+
     with gr.Row():
         with gr.Column(scale=1):
-            # REMOVIDO: componente gr.Image que causava erro 404
             gr.Markdown("### 🤖 N8n Bot")
-        
         with gr.Column(scale=4):
             gr.Markdown("## Como posso ajudar você com o n8n?")
-            
             with gr.Row():
                 with gr.Column(scale=3):
                     input_box = gr.Textbox(
@@ -255,19 +290,16 @@ with gr.Blocks(theme=gr.themes.Soft(), title="N8n Assistant") as demo:
                         placeholder="Ex: Como criar um workflow no n8n?",
                         lines=3
                     )
-                    
                     with gr.Row():
                         enviar_btn = gr.Button("🚀 Perguntar", variant="primary")
                         limpar_btn = gr.Button("🧹 Limpar")
-                
                 with gr.Column(scale=4):
                     output_box = gr.Textbox(
                         label="Resposta",
                         placeholder="Sua resposta aparecerá aqui...",
                         lines=12
                     )
-    
-    # Exemplos
+
     with gr.Accordion("💡 Exemplos de Perguntas", open=False):
         gr.Markdown(
             """
@@ -281,32 +313,10 @@ with gr.Blocks(theme=gr.themes.Soft(), title="N8n Assistant") as demo:
             - Quais nodes usar para automação de email?
             """
         )
-    
-    # Eventos
-    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_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)
 
-# Lançar aplicação
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )
-
+    demo.launch(server_name="0.0.0.0", server_port=7860, show_error=True)