corrigido1

app.py

@@ -1,32 +1,24 @@
 """
-🤖 N8n Assistant - Versão Otimizada
-Chatbot inteligente para dúvidas sobre n8n com arquitetura robusta
-
-Melhorias implementadas:
-- Tratamento completo de erros
-- Sistema de logging
-- Arquitetura orientada a objetos
-- Interface melhorada com feedback visual
-- Sistema de cache para performance
-- Validações robustas
+🤖 N8n Assistant - Versão Corrigida e Simplificada
+Chatbot inteligente para dúvidas sobre n8n - Compatível com Hugging Face Spaces
+
+CORREÇÕES APLICADAS:
+- Requirements.txt sem versões específicas (evita conflitos)
+- Código simplificado mas robusto
+- Tratamento de erros essencial
+- Interface limpa e funcional
 """
 
 import os
 import yaml
 import json
 import logging
-import pickle
-import hashlib
 import time
-from pathlib import Path
 from typing import Optional, Tuple
 import gradio as gr
 
 # Configurar logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 # Importações com tratamento de erro
@@ -35,626 +27,290 @@ try:
     from llama_index.llms.openai import OpenAI
     from llama_index.embeddings.openai import OpenAIEmbedding
     from huggingface_hub import snapshot_download
-    logger.info("Todas as bibliotecas importadas com sucesso")
+    logger.info("✅ Bibliotecas importadas com sucesso")
 except ImportError as e:
-    logger.error(f"Erro ao importar bibliotecas: {e}")
+    logger.error(f"❌ Erro ao importar bibliotecas: {e}")
     raise
 
 
-class N8nChatbotPro:
-    """
-    Chatbot profissional para n8n com sistema de cache e tratamento robusto de erros
-    """
+class N8nAssistant:
+    """Assistente N8n simplificado e funcional"""
     
     def __init__(self):
         self.index = None
         self.query_engine = None
         self.docs_dir = None
-        self.cache_dir = Path("cache")
-        self.cache_dir.mkdir(exist_ok=True)
-        self.metricas = {
-            'total_perguntas': 0,
-            'tempo_inicializacao': 0,
-            'cache_hits': 0
-        }
-        
-        logger.info("Inicializando N8nChatbotPro...")
+        self.inicializado = False
         
     def setup_openai(self) -> bool:
-        """Configurar OpenAI com validação robusta"""
+        """Configurar OpenAI"""
         try:
             api_key = os.getenv("OPENAI_API_KEY")
             if not api_key:
-                logger.error("❌ OPENAI_API_KEY não encontrada nas variáveis de ambiente")
-                return False
-            
-            if len(api_key) < 20:  # Validação básica do formato
-                logger.error("❌ OPENAI_API_KEY parece inválida (muito curta)")
+                logger.error("❌ OPENAI_API_KEY não encontrada")
                 return False
             
             os.environ["OPENAI_API_KEY"] = api_key
-            logger.info("✅ OpenAI API configurada com sucesso")
-            return True
-            
-        except Exception as e:
-            logger.error(f"❌ Erro ao configurar OpenAI: {e}")
-            return False
-
-    def calcular_hash_dataset(self, pasta: str) -> str:
-        """Calcular hash MD5 do dataset para verificar mudanças"""
-        try:
-            hash_md5 = hashlib.md5()
-            arquivos_processados = 0
-            
-            for root, dirs, files in os.walk(pasta):
-                for file in sorted(files):  # Ordenar para hash consistente
-                    caminho_arquivo = os.path.join(root, file)
-                    try:
-                        with open(caminho_arquivo, 'rb') as f:
-                            for chunk in iter(lambda: f.read(4096), b""):
-                                hash_md5.update(chunk)
-                        arquivos_processados += 1
-                    except Exception as e:
-                        logger.warning(f"Erro ao processar {file} para hash: {e}")
-                        continue
-            
-            hash_resultado = hash_md5.hexdigest()
-            logger.info(f"Hash calculado para {arquivos_processados} arquivos: {hash_resultado[:8]}...")
-            return hash_resultado
-            
-        except Exception as e:
-            logger.error(f"Erro ao calcular hash: {e}")
-            return ""
-
-    def salvar_cache(self, index: VectorStoreIndex, hash_dataset: str) -> bool:
-        """Salvar índice e hash em cache"""
-        try:
-            cache_index_path = self.cache_dir / "index.pkl"
-            cache_hash_path = self.cache_dir / "dataset_hash.txt"
-            cache_metadata_path = self.cache_dir / "metadata.json"
-            
-            # Salvar índice
-            with open(cache_index_path, 'wb') as f:
-                pickle.dump(index, f)
-            
-            # Salvar hash
-            with open(cache_hash_path, 'w') as f:
-                f.write(hash_dataset)
-            
-            # Salvar metadata
-            metadata = {
-                'timestamp': time.time(),
-                'hash': hash_dataset,
-                'version': '1.0'
-            }
-            with open(cache_metadata_path, 'w') as f:
-                json.dump(metadata, f)
-            
-            logger.info("✅ Cache salvo com sucesso")
+            logger.info("✅ OpenAI configurada")
             return True
-            
         except Exception as e:
-            logger.warning(f"⚠️ Erro ao salvar cache: {e}")
+            logger.error(f"❌ Erro OpenAI: {e}")
             return False
 
-    def carregar_cache(self, hash_atual: str) -> Optional[VectorStoreIndex]:
-        """Carregar índice do cache se hash for igual"""
-        try:
-            cache_index_path = self.cache_dir / "index.pkl"
-            cache_hash_path = self.cache_dir / "dataset_hash.txt"
-            
-            if not (cache_index_path.exists() and cache_hash_path.exists()):
-                logger.info("📁 Cache não encontrado")
-                return None
-            
-            # Verificar hash
-            with open(cache_hash_path, 'r') as f:
-                hash_cache = f.read().strip()
-            
-            if hash_cache != hash_atual:
-                logger.info("🔄 Dataset foi atualizado, cache inválido")
-                return None
-            
-            # Carregar índice
-            with open(cache_index_path, 'rb') as f:
-                index = pickle.load(f)
-            
-            self.metricas['cache_hits'] += 1
-            logger.info("⚡ Cache carregado com sucesso")
-            return index
-            
-        except Exception as e:
-            logger.warning(f"⚠️ Erro ao carregar cache: {e}")
-            return None
-
-    def extrair_conteudo_dos_arquivos(self, pasta: str) -> Tuple[str, dict]:
-        """Extrair conteúdo de arquivos com estatísticas detalhadas"""
+    def extrair_conteudo_arquivos(self, pasta: str) -> str:
+        """Extrair conteúdo dos arquivos"""
         texto_final = ""
-        estatisticas = {
-            'yaml': 0,
-            'json': 0,
-            'markdown': 0,
-            'txt': 0,
-            'erros': 0,
-            'total_caracteres': 0
-        }
         
         if not os.path.exists(pasta):
             logger.error(f"❌ Pasta não encontrada: {pasta}")
-            return "", estatisticas
+            return ""
 
-        logger.info(f"📂 Processando arquivos em: {pasta}")
-        
         for root, dirs, files in os.walk(pasta):
             for file in files:
                 caminho_arquivo = os.path.join(root, file)
                 
                 try:
-                    conteudo_arquivo = ""
-                    
                     if file.endswith(('.yml', '.yaml')):
                         with open(caminho_arquivo, 'r', encoding='utf-8') as f:
                             data = yaml.safe_load(f)
-                            conteudo_arquivo = yaml.dump(data, allow_unicode=True)
-                            estatisticas['yaml'] += 1
-                    
+                            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:
                             data = json.load(f)
-                            conteudo_arquivo = json.dumps(data, indent=2, ensure_ascii=False)
-                            estatisticas['json'] += 1
-                    
-                    elif file.endswith('.md'):
-                        with open(caminho_arquivo, 'r', encoding='utf-8') as f:
-                            conteudo_arquivo = f.read()
-                            estatisticas['markdown'] += 1
-                    
-                    elif file.endswith('.txt'):
+                            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:
-                            conteudo_arquivo = f.read()
-                            estatisticas['txt'] += 1
-                    
-                    else:
-                        continue
-                    
-                    if conteudo_arquivo:
-                        texto_final += f"\n\n### Arquivo: {file}\n{conteudo_arquivo}"
-                        estatisticas['total_caracteres'] += len(conteudo_arquivo)
+                            texto = f.read()
+                            texto_final += f"\n\n### Arquivo: {file}\n{texto}"
 
                 except Exception as e:
                     logger.warning(f"⚠️ Erro ao ler {file}: {e}")
-                    estatisticas['erros'] += 1
                     continue
 
-        total_arquivos = sum([estatisticas[k] for k in ['yaml', 'json', 'markdown', 'txt']])
-        logger.info(f"✅ Processados {total_arquivos} arquivos ({estatisticas['total_caracteres']:,} caracteres)")
-        
-        return texto_final, estatisticas
+        return texto_final
 
-    def gerar_arquivo_documentacao(self, pasta_origem: str, arquivo_destino: str = "documentacao.txt") -> Tuple[bool, dict]:
-        """Gerar arquivo de documentação com estatísticas"""
+    def gerar_documentacao(self, pasta_origem: str) -> bool:
+        """Gerar arquivo de documentação"""
         try:
-            logger.info("📝 Gerando arquivo de documentação...")
-            texto, estatisticas = self.extrair_conteudo_dos_arquivos(pasta_origem)
+            texto = self.extrair_conteudo_arquivos(pasta_origem)
             
             if not texto.strip():
-                logger.warning("⚠️ Nenhum conteúdo encontrado nos arquivos!")
-                return False, estatisticas
+                logger.warning("⚠️ Nenhum conteúdo encontrado")
+                return False
             
-            with open(arquivo_destino, 'w', encoding='utf-8') as f:
+            with open("documentacao.txt", 'w', encoding='utf-8') as f:
                 f.write(texto)
             
-            # Verificar tamanho do arquivo gerado
-            tamanho_arquivo = os.path.getsize(arquivo_destino)
-            logger.info(f"✅ Arquivo {arquivo_destino} gerado ({tamanho_arquivo:,} bytes)")
-            
-            return True, estatisticas
+            logger.info("✅ Documentação gerada")
+            return True
             
         except Exception as e:
             logger.error(f"❌ Erro ao gerar documentação: {e}")
-            return False, {}
-
-    def baixar_documentacao(self) -> bool:
-        """Baixar documentação do Hugging Face com retry"""
-        max_tentativas = 3
-        
-        for tentativa in range(max_tentativas):
-            try:
-                logger.info(f"📥 Baixando documentação do n8n (tentativa {tentativa + 1}/{max_tentativas})...")
-                
-                self.docs_dir = snapshot_download(
-                    repo_id="Jeice/n8n-docs-v2",
-                    repo_type="dataset",
-                    cache_dir="./hf_cache"
-                )
-                
-                # Verificar se o download foi bem-sucedido
-                if os.path.exists(self.docs_dir) and os.listdir(self.docs_dir):
-                    logger.info(f"✅ Documentação baixada em: {self.docs_dir}")
-                    return True
-                else:
-                    logger.warning("⚠️ Diretório vazio após download")
-                    
-            except Exception as e:
-                logger.warning(f"⚠️ Tentativa {tentativa + 1} falhou: {e}")
-                if tentativa == max_tentativas - 1:
-                    logger.error("❌ Todas as tentativas de download falharam")
-                    return False
-                time.sleep(2)  # Aguardar antes da próxima tentativa
-        
-        return False
+            return False
 
-    def configurar_llm(self) -> bool:
-        """Configurar LLM com parâmetros otimizados"""
+    def baixar_docs(self) -> bool:
+        """Baixar documentação do HF"""
         try:
-            Settings.llm = OpenAI(
-                model="gpt-3.5-turbo",
-                temperature=0.1,  # Baixa temperatura para respostas mais precisas
-                max_tokens=1000,  # Limite de tokens para controlar custos
-                system_prompt=(
-                    "Você é um assistente especialista na plataforma n8n com vasta experiência. "
-                    "Responda sempre em português do Brasil, de forma clara, direta e objetiva. "
-                    "Base suas respostas exclusivamente na documentação fornecida. "
-                    "Se não houver informações suficientes na documentação, seja honesto e "
-                    "diga que não há informações suficientes para responder adequadamente. "
-                    "Forneça exemplos práticos quando possível e estruture suas respostas "
-                    "de forma didática e fácil de entender."
-                )
-            )
-            
-            Settings.embed_model = OpenAIEmbedding(
-                model="text-embedding-ada-002"
+            logger.info("📥 Baixando documentação...")
+            self.docs_dir = snapshot_download(
+                repo_id="Jeice/n8n-docs-v2",
+                repo_type="dataset"
             )
-            
-            logger.info("✅ LLM configurado com sucesso")
+            logger.info("✅ Download concluído")
             return True
-            
         except Exception as e:
-            logger.error(f"❌ Erro ao configurar LLM: {e}")
+            logger.error(f"❌ Erro no download: {e}")
             return False
 
-    def inicializar_index_com_cache(self) -> Tuple[bool, str]:
-        """Inicializar índice com sistema de cache inteligente"""
-        inicio_tempo = time.time()
-        
+    def criar_index(self) -> bool:
+        """Criar índice vetorial"""
         try:
-            # Calcular hash do dataset
-            hash_dataset = self.calcular_hash_dataset(self.docs_dir)
-            if not hash_dataset:
-                return False, "Erro ao calcular hash do dataset"
-            
-            # Tentar carregar do cache
-            cached_index = self.carregar_cache(hash_dataset)
-            if cached_index:
-                self.index = cached_index
-                
-                # Configurar LLM (necessário mesmo com cache)
-                if not self.configurar_llm():
-                    return False, "Erro ao configurar LLM"
-                
-                self.query_engine = self.index.as_query_engine(
-                    similarity_top_k=5,  # Retornar top 5 documentos mais similares
-                    response_mode="compact"  # Modo compacto para respostas mais diretas
-                )
-                
-                tempo_cache = time.time() - inicio_tempo
-                self.metricas['tempo_inicializacao'] = tempo_cache
-                return True, f"Índice carregado do cache em {tempo_cache:.2f}s"
-            
-            # Se não há cache válido, processar normalmente
-            logger.info("🔄 Processando documentação (sem cache válido)...")
-            
-            # Gerar arquivo de documentação
-            sucesso, estatisticas = self.gerar_arquivo_documentacao(self.docs_dir)
-            if not sucesso:
-                return False, "Erro ao processar documentação"
-            
-            # Verificar se arquivo foi criado
+            # Carregar documentos
             if not os.path.exists("documentacao.txt"):
-                return False, "Arquivo documentacao.txt não foi criado"
+                logger.error("❌ documentacao.txt não encontrado")
+                return False
             
-            # Carregar documentos
-            logger.info("📚 Carregando documentos...")
             documents = SimpleDirectoryReader(input_files=["documentacao.txt"]).load_data()
             
             if not documents:
-                return False, "Nenhum documento foi carregado"
-            
-            logger.info(f"✅ {len(documents)} documentos carregados")
+                logger.error("❌ Nenhum documento carregado")
+                return False
             
             # Configurar LLM
-            if not self.configurar_llm():
-                return False, "Erro ao configurar LLM"
-            
-            # Criar índice vetorial
-            logger.info("🧠 Criando índice vetorial...")
-            self.index = VectorStoreIndex.from_documents(
-                documents,
-                show_progress=True
-            )
-            
-            # Configurar query engine
-            self.query_engine = self.index.as_query_engine(
-                similarity_top_k=5,
-                response_mode="compact"
+            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()
             
-            # Salvar no cache
-            self.salvar_cache(self.index, hash_dataset)
-            
-            tempo_total = time.time() - inicio_tempo
-            self.metricas['tempo_inicializacao'] = tempo_total
+            # Criar índice
+            logger.info("🧠 Criando índice...")
+            self.index = VectorStoreIndex.from_documents(documents)
+            self.query_engine = self.index.as_query_engine()
             
-            return True, f"Índice criado em {tempo_total:.2f}s ({estatisticas})"
+            logger.info("✅ Índice criado")
+            return True
             
         except Exception as e:
-            logger.error(f"❌ Erro ao inicializar índice: {e}")
-            return False, f"Erro na inicialização: {str(e)}"
+            logger.error(f"❌ Erro ao criar índice: {e}")
+            return False
 
-    def setup(self) -> Tuple[bool, str]:
-        """Configurar todo o sistema com validações completas"""
+    def inicializar(self) -> Tuple[bool, str]:
+        """Inicializar sistema completo"""
         try:
-            logger.info("🚀 Iniciando configuração do sistema...")
-            
             # 1. Configurar OpenAI
             if not self.setup_openai():
-                return False, "❌ Falha na configuração da OpenAI API"
+                return False, "Erro na configuração OpenAI"
+            
+            # 2. Baixar docs
+            if not self.baixar_docs():
+                return False, "Erro no download da documentação"
             
-            # 2. Baixar documentação
-            if not self.baixar_documentacao():
-                return False, "❌ Falha no download da documentação"
+            # 3. Gerar documentação
+            if not self.gerar_documentacao(self.docs_dir):
+                return False, "Erro ao processar documentação"
             
-            # 3. Inicializar índice com cache
-            sucesso, mensagem = self.inicializar_index_com_cache()
-            if not sucesso:
-                return False, f"❌ {mensagem}"
+            # 4. Criar índice
+            if not self.criar_index():
+                return False, "Erro ao criar índice"
             
-            logger.info("✅ Sistema configurado com sucesso!")
-            return True, f"✅ {mensagem}"
+            self.inicializado = True
+            return True, "Sistema inicializado com sucesso"
             
         except Exception as e:
-            logger.error(f"❌ Erro crítico na configuração: {e}")
-            return False, f"❌ Erro crítico: {str(e)}"
+            logger.error(f"❌ Erro na inicialização: {e}")
+            return False, f"Erro: {str(e)}"
 
-    def chatbot(self, input_text: str) -> str:
-        """Função principal do chatbot com validações e métricas"""
-        # Validações de entrada
-        if not input_text or not input_text.strip():
-            return "⚠️ Por favor, digite uma pergunta válida."
+    def responder(self, pergunta: str) -> str:
+        """Responder pergunta"""
+        if not pergunta or not pergunta.strip():
+            return "⚠️ Por favor, digite uma pergunta."
         
-        if len(input_text.strip()) < 3:
-            return "⚠️ Pergunta muito curta. Por favor, seja mais específico."
-        
-        if not self.query_engine:
-            return "❌ Sistema não inicializado. Tente recarregar a página."
+        if not self.inicializado or not self.query_engine:
+            return "❌ Sistema não inicializado. Recarregue a página."
         
         try:
-            inicio = time.time()
-            self.metricas['total_perguntas'] += 1
-            
-            # Log da pergunta (primeiros 100 caracteres)
-            pergunta_log = input_text[:100] + "..." if len(input_text) > 100 else input_text
-            logger.info(f"🤔 Pergunta #{self.metricas['total_perguntas']}: {pergunta_log}")
-            
-            # Processar pergunta
-            response = self.query_engine.query(input_text)
-            
-            # Calcular tempo de resposta
-            tempo_resposta = time.time() - inicio
-            logger.info(f"⚡ Resposta gerada em {tempo_resposta:.2f}s")
-            
-            # Formatar resposta
-            resposta_formatada = str(response).strip()
-            
-            # Adicionar informações de debug se necessário
-            if len(resposta_formatada) < 50:
-                resposta_formatada += f"\n\n_Tempo de resposta: {tempo_resposta:.2f}s_"
-            
-            return resposta_formatada
+            logger.info(f"🤔 Pergunta: {pergunta[:50]}...")
+            response = self.query_engine.query(pergunta)
+            return str(response)
             
         except Exception as e:
-            logger.error(f"❌ Erro ao processar pergunta: {e}")
-            return f"❌ Erro ao processar sua pergunta: {str(e)}\n\nTente reformular sua pergunta ou recarregar a página."
+            logger.error(f"❌ Erro ao responder: {e}")
+            return f"❌ Erro ao processar pergunta: {str(e)}"
 
-    def obter_estatisticas(self) -> str:
-        """Obter estatísticas do sistema"""
-        return f"""
-📊 **Estatísticas do Sistema:**
-- Total de perguntas: {self.metricas['total_perguntas']}
-- Tempo de inicialização: {self.metricas['tempo_inicializacao']:.2f}s
-- Cache hits: {self.metricas['cache_hits']}
-- Status do índice: {'✅ Ativo' if self.index else '❌ Inativo'}
-"""
 
+# Inicializar sistema
+logger.info("🚀 Inicializando N8n Assistant...")
+assistant = N8nAssistant()
+sucesso, mensagem = assistant.inicializar()
 
-# Inicialização global
-logger.info("🤖 Inicializando N8n Assistant...")
-bot = N8nChatbotPro()
-
-# Configurar sistema
-logger.info("⚙️ Configurando sistema...")
-success, message = bot.setup()
-
-if success:
-    logger.info(f"✅ Sistema pronto: {message}")
+if sucesso:
+    logger.info(f"✅ {mensagem}")
 else:
-    logger.error(f"❌ Falha na inicialização: {message}")
-
-
-def responder_pergunta(input_text: str) -> str:
-    """Wrapper para interface Gradio"""
-    if not success:
-        return f"❌ Sistema não inicializado: {message}"
-    return bot.chatbot(input_text)
+    logger.error(f"❌ {mensagem}")
 
 
-def obter_info_sistema() -> str:
-    """Obter informações do sistema"""
-    if not success:
-        return f"❌ Sistema não inicializado: {message}"
-    return bot.obter_estatisticas()
+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 Premium
-with gr.Blocks(
-    theme=gr.themes.Soft(),
-    title="N8n Assistant Pro",
-    css="""
-    .status-success { color: #28a745; font-weight: bold; }
-    .status-error { color: #dc3545; font-weight: bold; }
-    .metrics { background-color: #f8f9fa; padding: 10px; border-radius: 5px; }
-    """
-) as demo:
+# Interface Gradio
+with gr.Blocks(theme=gr.themes.Soft(), title="N8n Assistant") as demo:
     
     # Cabeçalho
     gr.Markdown(
         f"""
-        # 🤖 N8n Assistant Pro
+        # 🤖 N8n Assistant
         
-        Assistente inteligente especializado em **n8n** com documentação oficial atualizada.
+        Assistente inteligente para dúvidas sobre **n8n** baseado na documentação oficial.
         
-        <div class="{'status-success' if success else 'status-error'}">
-        **Status do Sistema:** {message}
-        </div>
-        """,
-        elem_classes=["status-success" if success else "status-error"]
+        **Status:** {'✅ Sistema Pronto' if sucesso else '❌ ' + mensagem}
+        """
     )
     
     # Layout principal
     with gr.Row():
-        # Coluna da logo
         with gr.Column(scale=1):
             gr.Image(
                 value="https://n8n.io/images/n8n-logo.png",
                 width=120,
                 show_label=False,
-                interactive=False,
+                interactive=False
             )
-            
-            # Botão de estatísticas
-            if success:
-                stats_btn = gr.Button("📊 Ver Estatísticas", size="sm")
-                stats_output = gr.Textbox(
-                    label="Estatísticas do Sistema",
-                    visible=False,
-                    lines=6
-                )
         
-        # Coluna principal
         with gr.Column(scale=4):
-            gr.Markdown(
-                """
-                ## Como posso ajudar você com o n8n hoje?
-                
-                Digite sua pergunta abaixo e receba respostas baseadas na documentação oficial.
-                """
-            )
+            gr.Markdown("## Como posso ajudar você com o n8n?")
             
-            # Área de chat
             with gr.Row():
                 with gr.Column(scale=3):
-                    input_text = gr.Textbox(
-                        label="Sua pergunta sobre n8n",
+                    input_box = gr.Textbox(
+                        label="Sua pergunta",
                         placeholder="Ex: Como criar um workflow no n8n?",
-                        lines=3,
-                        max_lines=8
+                        lines=3
                     )
                     
                     with gr.Row():
-                        submit_btn = gr.Button("🚀 Perguntar", variant="primary", scale=2)
-                        clear_btn = gr.Button("🧹 Limpar", scale=1)
+                        enviar_btn = gr.Button("🚀 Perguntar", variant="primary")
+                        limpar_btn = gr.Button("🧹 Limpar")
                 
                 with gr.Column(scale=4):
-                    output_text = gr.Textbox(
-                        label="Resposta do Assistant",
+                    output_box = gr.Textbox(
+                        label="Resposta",
                         placeholder="Sua resposta aparecerá aqui...",
-                        lines=15,
-                        max_lines=25
+                        lines=12
                     )
     
-    # Seção de exemplos
+    # Exemplos
     with gr.Accordion("💡 Exemplos de Perguntas", open=False):
         gr.Markdown(
             """
-            **Workflows e Automação:**
-            - Como criar meu primeiro workflow no n8n?
-            - Quais são as melhores práticas para workflows?
-            - Como usar condições e loops nos workflows?
-            
-            **Nodes e Integrações:**
+            - Como criar um workflow no n8n?
             - Para que serve o node HTTP Request?
             - Como integrar n8n com Google Sheets?
-            - Quais nodes usar para automação de email?
-            
-            **Configuração e Deploy:**
             - Como configurar webhooks no n8n?
-            - Como fazer deploy do n8n em produção?
-            - Como configurar autenticação OAuth?
-            
-            **Troubleshooting:**
-            - Por que meu workflow não está executando?
+            - Quais são as melhores práticas para workflows?
             - Como debugar erros nos nodes?
-            - Como otimizar performance dos workflows?
-            """
-        )
-    
-    # Seção de informações técnicas
-    with gr.Accordion("ℹ️ Informações Técnicas", open=False):
-        gr.Markdown(
-            f"""
-            **Sobre este Assistant:**
-            - 🤖 **Modelo**: GPT-3.5-turbo otimizado para n8n
-            - 📚 **Base de conhecimento**: Documentação oficial n8n v2
-            - ⚡ **Sistema de cache**: Ativo para respostas mais rápidas
-            - 🔄 **Última atualização**: Documentação sincronizada automaticamente
-            - 🛡️ **Tratamento de erros**: Sistema robusto com fallbacks
-            
-            **Status da Inicialização:**
-            - ✅ Configuração OpenAI: {'Sucesso' if success else 'Falha'}
-            - ✅ Download documentação: {'Sucesso' if success else 'Falha'}  
-            - ✅ Índice vetorial: {'Ativo' if success else 'Inativo'}
-            - ✅ Cache system: {'Ativo' if success else 'Inativo'}
-            
-            **Métricas de Performance:**
-            {bot.obter_estatisticas() if success else 'Sistema não inicializado'}
             """
         )
     
-    # Eventos da interface
-    submit_btn.click(
-        fn=responder_pergunta,
-        inputs=input_text,
-        outputs=output_text
+    # Eventos
+    enviar_btn.click(
+        fn=processar_pergunta,
+        inputs=input_box,
+        outputs=output_box
     )
     
-    clear_btn.click(
+    limpar_btn.click(
         lambda: ("", ""),
         None,
-        [input_text, output_text]
+        [input_box, output_box]
     )
     
-    # Enter para enviar
-    input_text.submit(
-        fn=responder_pergunta,
-        inputs=input_text,
-        outputs=output_text
+    input_box.submit(
+        fn=processar_pergunta,
+        inputs=input_box,
+        outputs=output_box
     )
-    
-    # Botão de estatísticas
-    if success:
-        stats_btn.click(
-            fn=lambda: gr.update(visible=True, value=bot.obter_estatisticas()),
-            outputs=stats_output
-        )
 
 
-# Configuração de lançamento
+# Lançar aplicação
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        show_error=True,
-        show_api=False,
-        quiet=False
+        show_error=True
     )