ss

agents/processing_agent.py

@@ -6,6 +6,7 @@ import asyncio
 from typing import Optional, Dict, Any
 from langchain_openai import ChatOpenAI
 from langchain_anthropic import ChatAnthropic
+from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_community.llms import HuggingFaceEndpoint
 from langchain.schema import HumanMessage
 
@@ -14,6 +15,7 @@ from utils.config import (
     AVAILABLE_MODELS,
     OPENAI_MODELS,
     ANTHROPIC_MODELS,
+    GOOGLE_MODELS,
     REFINEMENT_MODELS
 )
 
@@ -57,7 +59,17 @@ class ProcessingAgentManager:
                     max_retries=2,
                     timeout=60.0
                 )
-                
+
+            elif model_id in GOOGLE_MODELS:
+                # Gemini com configurações otimizadas
+                self.llm = ChatGoogleGenerativeAI(
+                    model=model_id,
+                    temperature=TEMPERATURE,
+                    max_tokens=4096,
+                    max_retries=2,
+                    timeout=60.0
+                )
+
             else:
                 # Modelos HuggingFace (refinement models)
                 self.llm = HuggingFaceEndpoint(

agents/sql_agent.py

@@ -7,6 +7,7 @@ import asyncio
 from typing import Optional, Dict, Any, List
 from langchain_openai import ChatOpenAI
 from langchain_anthropic import ChatAnthropic
+from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_community.agent_toolkits import create_sql_agent
 from langchain_community.utilities import SQLDatabase
 from langchain.callbacks.base import BaseCallbackHandler
@@ -18,7 +19,8 @@ from utils.config import (
     TEMPERATURE,
     AVAILABLE_MODELS,
     OPENAI_MODELS,
-    ANTHROPIC_MODELS
+    ANTHROPIC_MODELS,
+    GOOGLE_MODELS
 )
 
 class SQLQueryCaptureHandler(BaseCallbackHandler):
@@ -126,18 +128,34 @@ async def retry_with_backoff(func, max_retries=3, base_delay=1.0):
 
 
 
-def create_sql_agent_executor(db: SQLDatabase, model_name: str = "gpt-4o-mini"):
+def create_sql_agent_executor(db: SQLDatabase, model_name: str = "gpt-4o-mini", single_table_mode: bool = False, selected_table: str = None):
     """
     Cria um agente SQL usando LangChain com suporte a diferentes provedores
 
     Args:
         db: Objeto SQLDatabase do LangChain
         model_name: Nome do modelo a usar (OpenAI, Anthropic)
+        single_table_mode: Se deve restringir a uma única tabela
+        selected_table: Tabela específica para modo único
 
     Returns:
         Agente SQL configurado
     """
     try:
+        # Se modo tabela única, cria SQLDatabase restrito
+        if single_table_mode and selected_table:
+            # Cria uma nova instância do SQLDatabase restrita à tabela selecionada
+            restricted_db = SQLDatabase.from_uri(
+                db._engine.url,
+                include_tables=[selected_table]
+            )
+            logging.info(f"[SQL_AGENT] Criando agente em modo tabela única: {selected_table}")
+            db_to_use = restricted_db
+        else:
+            # Usa o SQLDatabase original (modo multi-tabela)
+            logging.info("[SQL_AGENT] Criando agente em modo multi-tabela")
+            db_to_use = db
+
         # Obtém o ID real do modelo
         model_id = AVAILABLE_MODELS.get(model_name, model_name)
 
@@ -164,6 +182,17 @@ def create_sql_agent_executor(db: SQLDatabase, model_name: str = "gpt-4o-mini"):
             )
             agent_type = "tool-calling"  # Claude usa tool-calling
 
+        elif model_id in GOOGLE_MODELS:
+            # Gemini com tool-calling e configurações otimizadas
+            llm = ChatGoogleGenerativeAI(
+                model=model_id,
+                temperature=TEMPERATURE,
+                max_tokens=4096,
+                max_retries=2,
+                timeout=60.0
+            )
+            agent_type = "tool-calling"  # Gemini usa tool-calling
+
         else:
             # Fallback para OpenAI
             llm = ChatOpenAI(
@@ -173,10 +202,10 @@ def create_sql_agent_executor(db: SQLDatabase, model_name: str = "gpt-4o-mini"):
             agent_type = "openai-tools"
             logging.warning(f"Modelo {model_name} não reconhecido, usando gpt-4o-mini como fallback")
 
-        # Cria o agente SQL
+        # Cria o agente SQL 
         sql_agent = create_sql_agent(
             llm=llm,
-            db=db,
+            db=db_to_use,  # Usa o SQLDatabase apropriado (restrito ou completo)
             agent_type=agent_type,
             verbose=True,
             max_iterations=MAX_ITERATIONS,
@@ -195,32 +224,41 @@ class SQLAgentManager:
     """
     Gerenciador do agente SQL com funcionalidades avançadas
     """
-    
-    def __init__(self, db: SQLDatabase, model_name: str = "gpt-4o-mini"):
+
+    def __init__(self, db: SQLDatabase, model_name: str = "gpt-4o-mini", single_table_mode: bool = False, selected_table: str = None):
         self.db = db
         self.model_name = model_name
+        self.single_table_mode = single_table_mode
+        self.selected_table = selected_table
         self.agent = None
         self._initialize_agent()
-    
+
     def _initialize_agent(self):
         """Inicializa o agente SQL"""
-        self.agent = create_sql_agent_executor(self.db, self.model_name)
+        self.agent = create_sql_agent_executor(self.db, self.model_name, self.single_table_mode, self.selected_table)
     
-    def recreate_agent(self, new_db: SQLDatabase = None, new_model: str = None):
+    def recreate_agent(self, new_db: SQLDatabase = None, new_model: str = None, single_table_mode: bool = None, selected_table: str = None):
         """
         Recria o agente com novos parâmetros
-        
+
         Args:
             new_db: Novo banco de dados (opcional)
             new_model: Novo modelo (opcional)
+            single_table_mode: Novo modo de tabela (opcional)
+            selected_table: Nova tabela selecionada (opcional)
         """
         if new_db:
             self.db = new_db
         if new_model:
             self.model_name = new_model
-        
+        if single_table_mode is not None:
+            self.single_table_mode = single_table_mode
+        if selected_table is not None:
+            self.selected_table = selected_table
+
         self._initialize_agent()
-        logging.info("Agente SQL recriado com sucesso")
+        mode_info = f"modo {'tabela única' if self.single_table_mode else 'multi-tabela'}"
+        logging.info(f"Agente SQL recriado com modelo {self.model_name} em {mode_info}")
     
     def _extract_text_from_claude_response(self, output) -> str:
         """
@@ -279,12 +317,13 @@ class SQLAgentManager:
             # Criar handler para capturar SQL
             sql_handler = SQLQueryCaptureHandler()
 
-            # Verifica se é agente Claude para aplicar retry
+            # Verifica se é agente Claude ou Gemini para aplicar retry
             model_id = getattr(self, 'model_name', '')
             is_claude = any(claude_model in model_id for claude_model in ANTHROPIC_MODELS)
+            is_gemini = any(gemini_model in model_id for gemini_model in GOOGLE_MODELS)
 
-            if is_claude:
-                # Usa retry com backoff para Claude
+            if is_claude or is_gemini:
+                # Usa retry com backoff para Claude e Gemini
                 response = await retry_with_backoff(
                     lambda: self.agent.invoke(
                         {"input": instruction},
@@ -342,7 +381,7 @@ class SQLAgentManager:
                 "intermediate_steps": [],
                 "success": False
             }
-    
+
     def get_agent_info(self) -> dict:
         """
         Retorna informações sobre o agente atual

agents/tools.py

@@ -10,6 +10,7 @@ from langchain_community.utilities import SQLDatabase
 from langchain_openai import ChatOpenAI
 from langchain_anthropic import ChatAnthropic
 import pandas as pd
+import sqlalchemy as sa
 
 from utils.config import (
     HUGGINGFACE_API_KEY,
@@ -102,58 +103,120 @@ def detect_query_type(user_query: str) -> str:
     else:
         return 'sql_query'  # SQL normal
 
-def prepare_processing_context(user_query: str, db_sample: pd.DataFrame) -> str:
+def prepare_processing_context(user_query: str, columns_data: dict, connection_type: str = "csv", single_table_mode: bool = False, selected_table: str = None, available_tables: list = None) -> str:
     """
-    Prepara o contexto inicial para o Processing Agent
+    Prepara o contexto inicial para o Processing Agent de forma dinâmica
+
+    NOVA IMPLEMENTAÇÃO: Recebe dados já processados pelo processing_node.py
+    para evitar consultas redundantes e garantir consistência
 
     Args:
         user_query: Pergunta do usuário
-        db_sample: Amostra dos dados do banco
+        columns_data: Dados das colunas já processados pelo processing_node.py
+        Formato: {"table_name": [{"column": "nome", "type": "tipo", "examples": "exemplos", "stats": "estatísticas"}]}
+        connection_type: Tipo de conexão ("csv" ou "postgresql")
+        single_table_mode: Se está em modo tabela única (PostgreSQL)
+        selected_table: Tabela selecionada (PostgreSQL modo único)
+        available_tables: Lista de tabelas disponíveis (PostgreSQL)
 
     Returns:
         Contexto formatado para o Processing Agent
     """
-    # Obtém informações detalhadas das colunas
+    logging.info(f"[TOOLS] ===== PREPARANDO CONTEXTO =====")
+    logging.info(f"[TOOLS] Connection type: {connection_type}")
+    logging.info(f"[TOOLS] Single table mode: {single_table_mode}")
+    logging.info(f"[TOOLS] Selected table: {selected_table}")
+    logging.info(f"[TOOLS] Available tables: {available_tables}")
+    logging.info(f"[TOOLS] Columns data keys: {list(columns_data.keys()) if columns_data else 'None'}")
+
+    # Processa os dados das colunas baseado no tipo de conexão
     column_info = []
-    for col in db_sample.columns:
-        col_data = db_sample[col].dropna()
-        if len(col_data) > 0:
-            # Exemplos de valores únicos (máximo 5)
-            unique_values = col_data.unique()[:5]
-            examples = ", ".join([str(v) for v in unique_values])
-
-            # Tipo de dados
-            dtype = str(col_data.dtype)
-
-            # Estatísticas básicas para colunas numéricas
-            stats = ""
-            if col_data.dtype in ['int64', 'float64']:
-                try:
-                    min_val = col_data.min()
-                    max_val = col_data.max()
-                    stats = f" | Min: {min_val}, Max: {max_val}"
-                except:
-                    pass
 
-            column_info.append(f"- {col} ({dtype}): {examples}{stats}")
+    if connection_type.lower() == "postgresql":
+        logging.info(f"[TOOLS] 🔵 PROCESSANDO POSTGRESQL")
+
+        if single_table_mode and selected_table:
+            # PostgreSQL - Modo tabela única: usa APENAS dados da tabela selecionada
+            logging.info(f"[TOOLS] 🔵 PostgreSQL MODO ÚNICO - tabela: {selected_table}")
+
+            table_data = columns_data.get(selected_table, [])
+            if table_data:
+                for col_info in table_data:
+                    column_line = f"- {col_info['column']} ({col_info['type']})"
+                    if col_info.get('examples'):
+                        column_line += f": {col_info['examples']}"
+                    if col_info.get('stats'):
+                        column_line += f"{col_info['stats']}"
+                    column_info.append(column_line)
+
+                logging.info(f"[TOOLS] ✅ PostgreSQL modo único processado: {len(column_info)} colunas")
+            else:
+                logging.warning(f"[TOOLS] ⚠️ Nenhum dado encontrado para tabela {selected_table}")
+
+        else:
+            # PostgreSQL - Modo multi-tabela: usa dados de TODAS as tabelas
+            logging.info(f"[TOOLS] 🔵 PostgreSQL MODO MULTI-TABELA - {len(columns_data)} tabelas")
+
+            for table_name, table_columns in columns_data.items():
+                column_info.append(f"\n**Tabela: {table_name}**")
+
+                if table_columns:
+                    for col_info in table_columns:
+                        column_line = f"- {col_info['column']} ({col_info['type']})"
+                        if col_info.get('examples'):
+                            column_line += f": {col_info['examples']}"
+                        if col_info.get('stats'):
+                            column_line += f"{col_info['stats']}"
+                        column_info.append(column_line)
+                else:
+                    column_info.append("- (Tabela sem dados ou colunas)")
 
-    columns_description = "\n".join(column_info)
+                logging.info(f"[TOOLS] ✅ Tabela {table_name} processada: {len(table_columns)} colunas")
 
-    # Adiciona algumas linhas de exemplo dos dados
-    sample_rows = []
-    num_rows_to_show = min(3, len(db_sample))
-    for i in range(num_rows_to_show):
-        row_data = []
-        for col in db_sample.columns:
-            value = db_sample.iloc[i][col]
-            # Trunca valores muito longos
-            str_value = str(value)
-            if len(str_value) > 30:
-                str_value = str_value[:27] + "..."
-            row_data.append(f"{col}: {str_value}")
-        sample_rows.append("  " + " | ".join(row_data))
-
-    sample_data = "\n".join(sample_rows) if sample_rows else "Nenhuma linha de exemplo disponível"
+            logging.info(f"[TOOLS] ✅ PostgreSQL multi-tabela processado: {len(column_info)} itens")
+
+    else:
+        # CSV/SQLite - usa APENAS dados da tabela CSV
+        logging.info(f"[TOOLS] 🟡 PROCESSANDO CSV/SQLITE")
+
+        # Para CSV, deve haver apenas uma entrada no columns_data
+        for table_name, table_columns in columns_data.items():
+            for col_info in table_columns:
+                column_line = f"- {col_info['column']} ({col_info['type']})"
+                if col_info.get('examples'):
+                    column_line += f": {col_info['examples']}"
+                if col_info.get('stats'):
+                    column_line += f"{col_info['stats']}"
+                column_info.append(column_line)
+
+        logging.info(f"[TOOLS] ✅ CSV/SQLite processado: {len(column_info)} colunas")
+
+    columns_description = "\n".join(column_info)
+    logging.info(f"[TOOLS] ===== CONTEXTO FINAL =====")
+    logging.info(f"[TOOLS] Total de itens no contexto: {len(column_info)}")
+    logging.info(f"[TOOLS] ===== FIM PREPARAÇÃO =====")
+
+    # Determina informações da tabela de forma dinâmica
+    if connection_type.lower() == "postgresql":
+        if single_table_mode and selected_table:
+            # Modo tabela única PostgreSQL
+            table_info = f"Nome da tabela: {selected_table}"
+            table_instructions = f'Use apenas as colunas que existem na tabela "{selected_table}".'
+            context_note = f"MODO TABELA ÚNICA ATIVO - Trabalhando apenas com a tabela '{selected_table}'"
+        else:
+            # Modo multi-tabela PostgreSQL
+            if available_tables:
+                tables_list = ", ".join(available_tables)
+                table_info = f"Tabelas disponíveis: {tables_list}"
+            else:
+                table_info = "Múltiplas tabelas disponíveis no PostgreSQL"
+            table_instructions = "Use as tabelas disponíveis no PostgreSQL. Pode fazer JOINs entre tabelas quando necessário."
+            context_note = "MODO MULTI-TABELA ATIVO - Pode usar todas as tabelas e fazer JOINs"
+    else:
+        # Para CSV/SQLite, usa tabela padrão
+        table_info = "Nome da tabela: tabela"
+        table_instructions = 'Use apenas as colunas que existem na tabela "tabela".'
+        context_note = "CONEXÃO CSV/SQLite - Dados convertidos para tabela única"
 
     context = f"""
     Você é um especialista em SQL que deve analisar a pergunta do usuário e gerar uma query SQL otimizada.
@@ -161,24 +224,18 @@ def prepare_processing_context(user_query: str, db_sample: pd.DataFrame) -> str:
     INSTRUÇÕES IMPORTANTES:
     1. Analise a pergunta do usuário e o contexto dos dados
     2. Gere uma query SQL precisa e otimizada
-    3. Use apenas as colunas que existem na tabela "tabela"
+    3. {table_instructions}
     4. Para cálculos complexos, use CTEs quando necessário
     5. Inclua LIMIT quando apropriado para evitar resultados excessivos
     6. Considere os tipos de dados e valores de exemplo
-    7. O periodo da base é de 18 de janeiro de 2025 a 6 de julho de 2025
-    8. Nunca altere o idioma de nomes ou termos da pergunta do usuário
-    9. Nosso idioma é Português do Brasil
-    10. Sempre mantenha os nomes de colunas de texto em MAISCULO
 
     CONTEXTO DOS DADOS:
-    Nome da tabela: tabela
+    {context_note}
+    {table_info}
 
-    Colunas disponíveis com tipos e exemplos:
+    Colunas disponíveis com tipos e exemplos (baseado na amostra atual):
     {columns_description}
 
-    Exemplos de linhas dos dados:
-    {sample_data}
-
     PERGUNTA DO USUÁRIO:
     {user_query}
 
@@ -209,16 +266,6 @@ def prepare_sql_context(user_query: str, db_sample: pd.DataFrame, suggested_quer
     contexto_base = (
         "Você é um assistente especializado em consultas SQL, geração de querySQL e análise de dados.\n"
         "Sua tarefa é responder à pergunta do usuário abaixo, gerando uma query SQL que retorne os dados necessários para responder a pergunta.\n\n"
-        """
-
-        REGRAS: 
-        
-        1. Sempre mantenha a escrita de nomes ou termos de valores das colunas de texto.
-        2. Nosso idioma é Português do Brasil
-        3. Sempre mantenha os nomes de colunas de texto em MAIUSCULO
-        4. Estamos no ano de 2025
-        5. O jeito certo de escrever é Hamburguer e não Hamburger, estamos no Brasil, o correto é Hamburguer
-        """
     )
 
     # Contexto com opção de query (se disponível)

app.py

@@ -31,18 +31,23 @@ logging.basicConfig(
 # Variáveis globais
 graph_manager = None
 show_history_flag = False
+connection_ready = False  # Controla se a conexão está pronta para uso
+chat_blocked = False      # Controla se o chat está bloqueado durante carregamento
 
 async def initialize_app():
     """Inicializa a aplicação"""
-    global graph_manager
-    
+    global graph_manager, connection_ready
+
     try:
         # Valida configurações
         validate_config()
-        
+
         # Inicializa o grafo
         graph_manager = await initialize_graph()
 
+        # Inicializa como conectado (base padrão já carregada)
+        connection_ready = True
+
         # Informa sobre o status do LangSmith
         if is_langsmith_enabled():
             logging.info(f"✅ LangSmith habilitado - Projeto: '{LANGSMITH_PROJECT}'")
@@ -67,7 +72,7 @@ def run_async(coro):
     
     return loop.run_until_complete(coro)
 
-def chatbot_response(user_input: str, selected_model: str, advanced_mode: bool = False, processing_enabled: bool = False, processing_model: str = "GPT-4o-mini") -> Tuple[str, Optional[str]]:
+def chatbot_response(user_input: str, selected_model: str, advanced_mode: bool = False, processing_enabled: bool = False, processing_model: str = "GPT-4o-mini", connection_type: str = "csv", postgresql_config: Optional[Dict] = None, selected_table: str = None, single_table_mode: bool = False) -> Tuple[str, Optional[str]]:
     """
     Processa resposta do chatbot usando LangGraph
 
@@ -77,6 +82,10 @@ def chatbot_response(user_input: str, selected_model: str, advanced_mode: bool =
         advanced_mode: Se deve usar refinamento avançado
         processing_enabled: Se o Processing Agent está habilitado
         processing_model: Modelo para o Processing Agent
+        connection_type: Tipo de conexão ("csv" ou "postgresql")
+        postgresql_config: Configuração postgresql (se aplicável)
+        selected_table: Tabela selecionada (para postgresql)
+        single_table_mode: Se deve usar apenas uma tabela (postgresql)
 
     Returns:
         Tupla com (resposta_texto, caminho_imagem_grafico)
@@ -93,7 +102,11 @@ def chatbot_response(user_input: str, selected_model: str, advanced_mode: bool =
             selected_model=selected_model,
             advanced_mode=advanced_mode,
             processing_enabled=processing_enabled,
-            processing_model=processing_model
+            processing_model=processing_model,
+            connection_type=connection_type,
+            postgresql_config=postgresql_config,
+            selected_table=selected_table,
+            single_table_mode=single_table_mode
         ))
 
         response_text = result.get("response", "Erro ao processar resposta")
@@ -146,7 +159,7 @@ def save_graph_image_to_temp(graph_image_id: str) -> Optional[str]:
 
 def handle_csv_upload(file) -> str:
     """
-    Processa upload de arquivo CSV
+    Processa upload de arquivo csv
 
     Args:
         file: Arquivo enviado pelo Gradio
@@ -173,9 +186,9 @@ def handle_csv_upload(file) -> str:
         if not os.path.exists(file.name):
             return f"❌ Arquivo não encontrado: {file.name}"
 
-        # Verifica se é um arquivo CSV
+        # Verifica se é um arquivo csv
         if not file.name.lower().endswith('.csv'):
-            return "❌ Por favor, selecione um arquivo CSV válido."
+            return "❌ Por favor, selecione um arquivo csv válido."
 
         # Verifica o tamanho do arquivo
         file_size = os.path.getsize(file.name)
@@ -238,6 +251,73 @@ def reset_system() -> str:
         logging.error(error_msg)
         return error_msg
 
+def handle_postgresql_connection(host: str, port: str, database: str, username: str, password: str) -> str:
+    """
+    Processa conexão postgresql
+
+    Args:
+        host: Host do postgresql
+        port: Porta do postgresql
+        database: Nome do banco
+        username: Nome de usuário
+        password: Senha
+
+    Returns:
+        Mensagem de feedback
+    """
+    global graph_manager
+
+    if not graph_manager:
+        return "❌ Sistema não inicializado."
+
+    try:
+        # Valida campos obrigatórios
+        if not all([host, port, database, username, password]):
+            return "❌ Todos os campos são obrigatórios para conexão postgresql."
+
+        # Valida porta
+        try:
+            port_int = int(port)
+            if port_int < 1 or port_int > 65535:
+                return "❌ Porta deve estar entre 1 e 65535."
+        except ValueError:
+            return "❌ Porta deve ser um número válido."
+
+        # Prepara configuração postgresql
+        postgresql_config = {
+            "host": host.strip(),
+            "port": port_int,
+            "database": database.strip(),
+            "username": username.strip(),
+            "password": password
+        }
+
+        # Cria estado inicial para a conexão
+        initial_state = {
+            "user_input": "Conectar postgresql",
+            "selected_model": "gpt-4o-mini",
+            "advanced_mode": False,
+            "processing_enabled": False,
+            "processing_model": "gpt-4o-mini",
+            "connection_type": "postgresql",
+            "postgresql_config": postgresql_config,
+            "selected_table": None,
+            "single_table_mode": False
+        }
+
+        # Processa conexão através do LangGraph
+        logging.info(f"[POSTGRESQL] Iniciando conexão: {host}:{port}/{database}")
+        result = run_async(graph_manager.handle_postgresql_connection(initial_state))
+
+        logging.info(f"[POSTGRESQL] Resultado da conexão: {result}")
+        return result.get("message", "Erro na conexão postgresql")
+
+    except Exception as e:
+        error_msg = f"❌ Erro ao conectar postgresql: {e}"
+        logging.error(error_msg)
+        logging.error(f"[POSTGRESQL] Detalhes do erro: {type(e).__name__}: {str(e)}")
+        return error_msg
+
 def toggle_advanced_mode(enabled: bool) -> str:
     """
     Alterna modo avançado
@@ -266,7 +346,7 @@ def toggle_history():
     else:
         return {}
 
-def respond(message: str, chat_history: List[Dict[str, str]], selected_model: str, advanced_mode: bool, processing_enabled: bool = False, processing_model: str = "GPT-4o-mini"):
+def respond(message: str, chat_history: List[Dict[str, str]], selected_model: str, advanced_mode: bool, processing_enabled: bool = False, processing_model: str = "GPT-4o-mini", connection_type: str = "csv", postgresql_config: Optional[Dict] = None, selected_table: str = None, single_table_mode: bool = False):
     """
     Função de resposta para o chatbot Gradio
 
@@ -277,6 +357,10 @@ def respond(message: str, chat_history: List[Dict[str, str]], selected_model: st
         advanced_mode: Modo avançado habilitado
         processing_enabled: Se o Processing Agent está habilitado
         processing_model: Modelo para o Processing Agent
+        connection_type: Tipo de conexão ("csv" ou "postgresql")
+        postgresql_config: Configuração postgresql (se aplicável)
+        selected_table: Tabela selecionada (para postgresql)
+        single_table_mode: Se deve usar apenas uma tabela (postgresql)
 
     Returns:
         Tupla com (mensagem_vazia, histórico_atualizado, imagem_grafico)
@@ -294,7 +378,7 @@ def respond(message: str, chat_history: List[Dict[str, str]], selected_model: st
         return "", chat_history, None
 
     # Processa resposta
-    response, graph_image_path = chatbot_response(message, selected_model, advanced_mode, processing_enabled, processing_model)
+    response, graph_image_path = chatbot_response(message, selected_model, advanced_mode, processing_enabled, processing_model, connection_type, postgresql_config, selected_table, single_table_mode)
 
     # Atualiza histórico no formato messages
     chat_history.append({"role": "user", "content": message})
@@ -304,16 +388,126 @@ def respond(message: str, chat_history: List[Dict[str, str]], selected_model: st
 
 def handle_csv_and_clear_chat(file):
     """
-    Processa CSV e limpa chat
+    Processa csv e limpa chat com indicador de carregamento melhorado
 
     Args:
-        file: Arquivo CSV
+        file: Arquivo csv
 
     Returns:
-        Tupla com (feedback, chat_limpo, grafico_limpo)
+        Tupla com (feedback, chat_limpo, grafico_limpo, status)
     """
+    global connection_ready
+
+    if file is None:
+        connection_ready = False
+        return "", [], gr.update(visible=False), "**Status**: <span class='status-error'>Nenhum arquivo selecionado</span>"
+
+    # Indica carregamento
+    connection_ready = False
+
+    # Processa arquivo
     feedback = handle_csv_upload(file)
-    return feedback, [], gr.update(visible=False)
+
+    # Status final baseado no resultado
+    if "✅" in feedback:
+        connection_ready = True
+        final_status = "**Status**: <span class='status-connected'>csv processado com sucesso</span>"
+    else:
+        connection_ready = False
+        final_status = "**Status**: <span class='status-error'>Erro no processamento do csv</span>"
+
+    return feedback, [], gr.update(visible=False), final_status
+
+def is_connection_ready(conn_type, pg_host=None, pg_port=None, pg_db=None, pg_user=None, pg_pass=None):
+    """
+    Verifica se há uma conexão de dados ativa e pronta para uso
+
+    Args:
+        conn_type: Tipo de conexão ("csv" ou "postgresql")
+        pg_host, pg_port, pg_db, pg_user, pg_pass: Credenciais postgresql
+
+    Returns:
+        True se conexão está pronta, False caso contrário
+    """
+    global connection_ready, chat_blocked
+    return connection_ready and not chat_blocked
+
+def show_loading_in_chat(message):
+    """
+    Mostra mensagem de carregamento apenas no chat
+
+    Args:
+        message: Mensagem de carregamento
+
+    Returns:
+        Histórico atualizado com mensagem de carregamento
+    """
+    global chat_blocked
+    chat_blocked = True
+
+    return [
+        {"role": "user", "content": "Alterando tipo de conexão..."},
+        {"role": "assistant", "content": f"🔄 {message}"}
+    ]
+
+def clear_loading_from_chat():
+    """
+    Remove carregamento do chat
+    """
+    global chat_blocked
+    chat_blocked = False
+
+def load_default_csv_and_cleanup_postgresql():
+    """
+    Carrega a base csv padrão e limpa conexões postgresql ativas
+
+    Returns:
+        Mensagem de feedback sobre a operação
+    """
+    global connection_ready
+
+    try:
+        from utils.config import DEFAULT_CSV_PATH
+        from utils.object_manager import get_object_manager
+        import os
+
+        # Verifica se o arquivo padrão existe
+        if not os.path.exists(DEFAULT_CSV_PATH):
+            connection_ready = False
+            return "Arquivo csv padrão (tabela.csv) não encontrado"
+
+        # Limpa conexões postgresql ativas
+        obj_manager = get_object_manager()
+
+        # Fecha engines postgresql (SQLAlchemy engines têm método dispose)
+        for engine_id, engine in obj_manager._engines.items():
+            try:
+                if hasattr(engine, 'dispose'):
+                    engine.dispose()
+                    logging.info(f"[CLEANUP] Engine postgresql {engine_id} fechada")
+            except Exception as e:
+                logging.warning(f"[CLEANUP] Erro ao fechar engine {engine_id}: {e}")
+
+        # Limpa objetos postgresql do ObjectManager
+        obj_manager.clear_all()
+        logging.info("[CLEANUP] Objetos postgresql limpos do ObjectManager")
+
+        # Carrega csv padrão através do LangGraph
+        logging.info(f"[CSV_DEFAULT] Carregando arquivo padrão: {DEFAULT_CSV_PATH}")
+        result = run_async(graph_manager.handle_csv_upload(DEFAULT_CSV_PATH))
+
+        if result.get("success", False):
+            connection_ready = True
+            return f"✅ Base padrão carregada: {os.path.basename(DEFAULT_CSV_PATH)}"
+        else:
+            connection_ready = False
+            return f"Erro ao carregar base padrão: {result.get('message', 'Erro desconhecido')}"
+
+    except Exception as e:
+        connection_ready = False
+        error_msg = f"Erro ao carregar base padrão: {e}"
+        logging.error(f"[CSV_DEFAULT] {error_msg}")
+        return error_msg
 
 def reset_all():
     """
@@ -329,11 +523,121 @@ def reset_all():
 def create_interface():
     """Cria interface Gradio"""
 
-    # CSS customizado para pequeno espaçamento lateral
+    # CSS customizado para interface limpa e moderna
     custom_css = """
     .gradio-container {
         padding: 20px 30px !important;
     }
+
+    /* Seções de configuração */
+    .config-section {
+        background: #f8f9fa;
+        border-radius: 15px;
+        padding: 0;
+        margin: 16px 0;
+        overflow: hidden;
+    }
+
+    /* Headers dos containers com espaçamento adequado */
+    .gradio-container h3 {
+        margin: 0 !important;
+        color: #f1f3f4 !important;
+        font-size: 16px !important;
+        font-weight: 600 !important;
+    }
+
+    /* Espaçamento para status e informações nos containers */
+    .config-section .status-connected,
+    .config-section .status-loading,
+    .config-section .status-error,
+    .config-section .status-waiting {
+        padding: 8px 20px !important;
+        display: block !important;
+    }
+
+    .prose.svelte-lag733 {
+        padding: 12px 20px !important;
+        margin: 0 !important;
+    }
+
+    /* Conteúdo dos containers */
+    .config-content {
+        padding: 20px;
+    }
+
+    /* Status indicators melhorados */
+    .status-connected {
+        color: #28a745;
+        font-weight: 600;
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+    }
+
+    .status-loading {
+        color: #ffc107;
+        font-weight: 600;
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+    }
+
+    .status-loading::before {
+        content: "⏳";
+        animation: pulse 1.5s infinite;
+    }
+
+    .status-error {
+        color: #dc3545;
+        font-weight: 600;
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+    }
+
+    .status-waiting {
+        color: #6c757d;
+        font-weight: 500;
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+    }
+
+    /* Animação de carregamento */
+    @keyframes pulse {
+        0%, 100% { opacity: 1; }
+        50% { opacity: 0.5; }
+    }
+
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+
+    /* Espaçamentos internos */
+    .gr-form {
+        padding: 16px;
+    }
+
+    .gr-box {
+        padding: 16px;
+        margin: 12px 0;
+    }
+
+    /* Melhorias para seção postgresql */
+    .pg-section {
+        background: #f8f9fa;
+        border-radius: 8px;
+        padding: 16px;
+        margin: 12px 0;
+    }
+
+    .pg-feedback {
+        padding: 12px;
+        margin: 8px 0;
+        border-radius: 6px;
+        background: #f1f3f4;
+    }
     """
 
     with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
@@ -341,30 +645,142 @@ def create_interface():
         with gr.Row():
             with gr.Column(scale=1):
                 gr.Markdown("## Configurações")
-                model_selector = gr.Dropdown(list(AVAILABLE_MODELS.keys()), value=DEFAULT_MODEL, label="")
-                csv_file = gr.File(file_types=[".csv"], label="")
-                upload_feedback = gr.Markdown()
-                advanced_checkbox = gr.Checkbox(label="Refinar Resposta")
-
-                # Controles do Processing Agent
-                processing_checkbox = gr.Checkbox(label="Usar Processing Agent", value=False)
-                processing_model_selector = gr.Dropdown(
-                    choices=list(AVAILABLE_MODELS.keys()) + list(REFINEMENT_MODELS.keys()),
-                    value="GPT-4o-mini",  # Chave correta do AVAILABLE_MODELS
-                    label="Modelo do Processing Agent",
-                    visible=False
-                )
-
-                # Status do LangSmith
-                if is_langsmith_enabled():
-                    gr.Markdown(f"🔍 **LangSmith**: Ativo")
-                else:
-                    gr.Markdown("🔍 **LangSmith**: Desabilitado")
 
-                reset_btn = gr.Button("Resetar")
+                # 1. CONEXÃO DE DADOS
+                with gr.Group():
+                    gr.Markdown("### Conexão de Dados")
+
+                    with gr.Group():
+                        connection_type = gr.Radio(
+                            choices=[("CSV", "csv"), ("PostgreSQL", "postgresql")],
+                            value="csv",
+                            label="Tipo de Conexão"
+                        )
+
+                        # Status da conexão
+                        connection_status = gr.Markdown("**Status**: <span class='status-connected'>Base padrão carregada</span>")
+
+                # Seção csv
+                with gr.Group(visible=True) as csv_section:
+                    csv_file = gr.File(
+                        file_types=[".csv"],
+                        label="Arquivo csv"
+                    )
+                    upload_feedback = gr.Markdown()
+
+                # Seção postgresql
+                with gr.Group(visible=False) as postgresql_section:
+                    with gr.Group():
+                        with gr.Row():
+                            pg_host = gr.Textbox(
+                                label="Host",
+                                placeholder="localhost",
+                                scale=2
+                            )
+                            pg_port = gr.Textbox(
+                                label="Porta",
+                                value="5432",
+                                placeholder="5432",
+                                scale=1
+                            )
+
+                        pg_database = gr.Textbox(
+                            label="Banco de Dados",
+                            placeholder="nome_do_banco"
+                        )
+
+                        with gr.Row():
+                            pg_username = gr.Textbox(
+                                label="Usuário",
+                                placeholder="usuario",
+                                scale=1
+                            )
+                            pg_password = gr.Textbox(
+                                label="Senha",
+                                type="password",
+                                placeholder="senha",
+                                scale=1
+                            )
+
+                        pg_connect_btn = gr.Button(
+                            "Conectar postgresql",
+                            variant="primary",
+                            size="lg"
+                        )
+
+                        pg_feedback = gr.Markdown()
+
+                    # Configuração de tabelas (visível após conexão)
+                    with gr.Group(visible=False) as pg_table_section:
+                        gr.Markdown("#### Configuração de Tabelas")
+
+                        with gr.Group():
+                            pg_single_table_mode = gr.Checkbox(
+                                label="Modo Tabela Única",
+                                value=False
+                            )
+
+                            # Seletor de tabela
+                            with gr.Group(visible=False) as pg_table_selector_group:
+                                pg_table_selector = gr.Dropdown(
+                                    choices=[],
+                                    label="Selecionar Tabela",
+                                    interactive=True
+                                )
+
+                            pg_table_info = gr.Markdown()
+
+                # 2. CONFIGURAÇÃO DE MODELOS
+                with gr.Group():
+                    gr.Markdown("### Configuração de Agentes")
+
+                    with gr.Group():
+                        # Processing Agent
+                        processing_checkbox = gr.Checkbox(
+                            label="Processing Agent",
+                            value=False
+                        )
+                        processing_model_selector = gr.Dropdown(
+                            choices=list(AVAILABLE_MODELS.keys()) + list(REFINEMENT_MODELS.keys()),
+                            value="GPT-4o-mini",
+                            label="Modelo do Processing Agent",
+                            visible=False
+                        )
+
+                        # Modelo principal SQL
+                        model_selector = gr.Dropdown(
+                            list(AVAILABLE_MODELS.keys()),
+                            value=DEFAULT_MODEL,
+                            label="Modelo SQL Principal"
+                        )
+
+                # 3. CONFIGURAÇÕES AVANÇADAS
+                with gr.Group():
+                    gr.Markdown("### Configurações Avançadas")
+
+                    with gr.Group():
+                        advanced_checkbox = gr.Checkbox(
+                            label="Refinar Resposta"
+                        )
+
+                # 4. STATUS E CONTROLES
+                with gr.Group():
+                    gr.Markdown("### Status do Sistema")
+
+                    with gr.Group():
+                        # Status do LangSmith
+                        if is_langsmith_enabled():
+                            gr.Markdown(f"**LangSmith**: Ativo")
+                        else:
+                            gr.Markdown("**LangSmith**: Desabilitado")
+
+                        reset_btn = gr.Button(
+                            "Resetar Sistema",
+                            variant="secondary"
+                        )
                 
             with gr.Column(scale=4):
-                gr.Markdown("## Seara Agent")
+                gr.Markdown("## Agent86")
                 chatbot = gr.Chatbot(
                     height=600,
                     show_label=False,
@@ -390,10 +806,38 @@ def create_interface():
 
                 download_file = gr.File(visible=False)
         
+        # Função para mostrar carregamento de transição no chat
+        def show_transition_loading(conn_type):
+            """Mostra carregamento de transição apenas no chat"""
+            if conn_type == "csv":
+                loading_chat = show_loading_in_chat("Fechando postgresql e carregando base csv padrão...")
+                return "", loading_chat, gr.update(visible=False)
+            else:
+                return "", [], gr.update(visible=False)
+
         # Event handlers (usando as funções originais do sistema)
-        def handle_response_with_graph(message, chat_history, model, advanced, processing_enabled, processing_model):
+        def handle_response_with_graph(message, chat_history, model, advanced, processing_enabled, processing_model, conn_type, pg_host, pg_port, pg_db, pg_user, pg_pass, pg_table, pg_single_mode):
             """Wrapper para lidar com resposta e gráfico"""
-            empty_msg, updated_history, graph_path = respond(message, chat_history, model, advanced, processing_enabled, processing_model)
+
+            # Verifica se há conexão ativa antes de processar
+            if not is_connection_ready(conn_type, pg_host, pg_port, pg_db, pg_user, pg_pass):
+                error_msg = "⚠️ **Aguarde**: Configure e conecte a uma fonte de dados antes de fazer perguntas."
+                chat_history.append({"role": "user", "content": message})
+                chat_history.append({"role": "assistant", "content": error_msg})
+                return "", chat_history, gr.update(visible=False)
+
+            # Prepara configuração postgresql se necessário
+            postgresql_config = None
+            if conn_type == "postgresql":
+                postgresql_config = {
+                    "host": pg_host,
+                    "port": pg_port,
+                    "database": pg_db,
+                    "username": pg_user,
+                    "password": pg_pass
+                }
+
+            empty_msg, updated_history, graph_path = respond(message, chat_history, model, advanced, processing_enabled, processing_model, conn_type, postgresql_config, pg_table, pg_single_mode)
 
             # Controla visibilidade do componente de gráfico
             if graph_path:
@@ -405,22 +849,147 @@ def create_interface():
             """Controla visibilidade do seletor de modelo do Processing Agent"""
             return gr.update(visible=enabled)
 
+        def toggle_connection_type(conn_type):
+            """Controla visibilidade das seções de conexão - FECHA POSTGRES IMEDIATAMENTE"""
+            global connection_ready
+
+            if conn_type == "csv":
+                # PRIMEIRO: Fecha container postgresql imediatamente
+                # SEGUNDO: Executa transição em background
+                feedback_msg = load_default_csv_and_cleanup_postgresql()
+                if "✅" in feedback_msg:
+                    connection_ready = True
+                    status_msg = "**Status**: <span class='status-connected'>Base padrão carregada</span>"
+                else:
+                    connection_ready = False
+                    status_msg = "**Status**: <span class='status-error'>Erro na conexão</span>"
+
+                return (
+                    gr.update(visible=True),   # csv_section - MOSTRA IMEDIATAMENTE
+                    gr.update(visible=False),  # postgresql_section - FECHA IMEDIATAMENTE
+                    feedback_msg,              # upload_feedback
+                    status_msg,                # connection_status
+                    # Limpa campos postgresql IMEDIATAMENTE
+                    gr.update(value=""),       # pg_host
+                    gr.update(value="5432"),   # pg_port
+                    gr.update(value=""),       # pg_database
+                    gr.update(value=""),       # pg_username
+                    gr.update(value=""),       # pg_password
+                    gr.update(value=""),       # pg_feedback
+                    gr.update(visible=False),  # pg_table_section
+                    gr.update(value=False),    # pg_single_table_mode
+                    gr.update(visible=False),  # pg_table_selector_group
+                    gr.update(choices=[], value=None),  # pg_table_selector
+                    gr.update(value="")        # pg_table_info
+                )
+
+            else:  # postgresql
+                connection_ready = False
+                status_msg = "**Status**: <span class='status-waiting'>Aguardando configuração postgresql</span>"
+                return (
+                    gr.update(visible=False),  # csv_section
+                    gr.update(visible=True),   # postgresql_section
+                    "",                        # upload_feedback
+                    status_msg,                # connection_status
+                    # Mantém campos postgresql como estão
+                    gr.update(),  # pg_host
+                    gr.update(),  # pg_port
+                    gr.update(),  # pg_database
+                    gr.update(),  # pg_username
+                    gr.update(),  # pg_password
+                    gr.update(),  # pg_feedback
+                    gr.update(),  # pg_table_section
+                    gr.update(),  # pg_single_table_mode
+                    gr.update(),  # pg_table_selector_group
+                    gr.update(),  # pg_table_selector
+                    gr.update()   # pg_table_info
+                )
+
+        def handle_postgresql_connect(host, port, database, username, password):
+            """Wrapper para conexão postgresql"""
+            global connection_ready
+
+            # Executa conexão
+            connection_ready = False
+            result = handle_postgresql_connection(host, port, database, username, password)
+
+            # Se conexão foi bem-sucedida, retorna tabelas disponíveis
+            if "✅" in result:
+                connection_ready = True
+                try:
+                    # Obtém tabelas do ObjectManager
+                    from utils.object_manager import get_object_manager
+                    obj_manager = get_object_manager()
+
+                    # Busca metadados de conexão mais recente
+                    all_metadata = obj_manager.get_all_connection_metadata()
+                    if all_metadata:
+                        latest_metadata = list(all_metadata.values())[-1]
+                        tables = latest_metadata.get("tables", [])
+
+                        # Status de sucesso
+                        success_status = "**Status**: <span class='status-connected'>postgresql conectado com sucesso</span>"
+                        table_info = f"**Modo Multi-Tabela ativo** - {len(tables)} tabelas disponíveis"
+
+                        # Retorna resultado + atualização do seletor
+                        return (
+                            f"✅ **Conectado com sucesso!** {len(tables)} tabelas encontradas",  # feedback
+                            gr.update(visible=True),  # pg_table_section
+                            False,  # pg_single_table_mode (padrão desativado)
+                            gr.update(visible=False),  # pg_table_selector_group (oculto por padrão)
+                            gr.update(choices=tables, value=tables[0] if tables else None),  # pg_table_selector
+                            table_info,  # pg_table_info
+                            success_status  # connection_status
+                        )
+                except Exception as e:
+                    logging.error(f"Erro ao obter tabelas: {e}")
+
+            # Se falhou, mantém seção de tabela oculta
+            connection_ready = False
+            error_status = "**Status**: <span class='status-error'>Falha na conexão postgresql</span>"
+            return (
+                result,  # feedback
+                gr.update(visible=False),  # pg_table_section
+                False,  # pg_single_table_mode
+                gr.update(visible=False),  # pg_table_selector_group
+                gr.update(choices=[], value=None),  # pg_table_selector
+                "",  # pg_table_info
+                error_status  # connection_status
+            )
+
+        def toggle_table_mode(single_mode_enabled, current_table):
+            """Alterna entre modo multi-tabela e tabela única"""
+            if single_mode_enabled:
+                # Modo tabela única ativado
+                return (
+                    gr.update(visible=True),  # pg_table_selector_group
+                    f"**Modo Tabela Única ativo** - Usando: {current_table or 'Selecione uma tabela'}"
+                )
+            else:
+                # Modo multi-tabela ativado
+                return (
+                    gr.update(visible=False),  # pg_table_selector_group
+                    "**Modo Multi-Tabela ativo** - Pode usar todas as tabelas e fazer JOINs"
+                )
+
         msg.submit(
             handle_response_with_graph,
-            inputs=[msg, chatbot, model_selector, advanced_checkbox, processing_checkbox, processing_model_selector],
-            outputs=[msg, chatbot, graph_image]
+            inputs=[msg, chatbot, model_selector, advanced_checkbox, processing_checkbox, processing_model_selector, connection_type, pg_host, pg_port, pg_database, pg_username, pg_password, pg_table_selector, pg_single_table_mode],
+            outputs=[msg, chatbot, graph_image],
+            show_progress=True  # Mostra carregamento no input do chat
         )
 
         btn.click(
             handle_response_with_graph,
-            inputs=[msg, chatbot, model_selector, advanced_checkbox, processing_checkbox, processing_model_selector],
+            inputs=[msg, chatbot, model_selector, advanced_checkbox, processing_checkbox, processing_model_selector, connection_type, pg_host, pg_port, pg_database, pg_username, pg_password, pg_table_selector, pg_single_table_mode],
             outputs=[msg, chatbot, graph_image]
         )
 
         csv_file.change(
             handle_csv_and_clear_chat,
             inputs=csv_file,
-            outputs=[upload_feedback, chatbot, graph_image]
+            outputs=[upload_feedback, chatbot, graph_image, connection_status],
+            show_progress="minimal"  # Mostra carregamento mínimo
         )
 
         reset_btn.click(
@@ -444,6 +1013,33 @@ def create_interface():
             inputs=processing_checkbox,
             outputs=processing_model_selector
         )
+
+        # Executa toggle imediatamente (sem carregamento nos campos)
+        connection_type.change(
+            toggle_connection_type,
+            inputs=connection_type,
+            outputs=[
+                csv_section, postgresql_section, upload_feedback, connection_status,
+                pg_host, pg_port, pg_database, pg_username, pg_password, pg_feedback,
+                pg_table_section, pg_single_table_mode, pg_table_selector_group,
+                pg_table_selector, pg_table_info
+            ],
+            show_progress=False  # Não mostra carregamento nos campos
+        )
+
+        pg_connect_btn.click(
+            handle_postgresql_connect,
+            inputs=[pg_host, pg_port, pg_database, pg_username, pg_password],
+            outputs=[pg_feedback, pg_table_section, pg_single_table_mode, pg_table_selector_group, pg_table_selector, pg_table_info, connection_status],
+            show_progress="minimal"  # Mostra carregamento mínimo
+        )
+
+        # Event handler para toggle de modo de tabela
+        pg_single_table_mode.change(
+            toggle_table_mode,
+            inputs=[pg_single_table_mode, pg_table_selector],
+            outputs=[pg_table_selector_group, pg_table_info]
+        )
     
     return demo
 
@@ -465,9 +1061,17 @@ async def main():
     for port in ports_to_try:
         try:
             logging.info(f"Tentando iniciar interface Gradio na porta {port}")
+
+            # Configurações para Docker
+            server_name = "0.0.0.0" if GRADIO_SHARE else "127.0.0.1"
+
+            if GRADIO_SHARE:
+                logging.info("🌐 Configurando link público do Gradio...")
+
             demo.launch(
-                share=GRADIO_SHARE,
+                server_name=server_name,
                 server_port=port if port != 0 else None,
+                share=GRADIO_SHARE,
                 show_error=True,
                 quiet=False
             )

graphs/main_graph.py

@@ -43,6 +43,12 @@ from nodes.cache_node import (
 from nodes.graph_selection_node import graph_selection_node
 from nodes.graph_generation_node import graph_generation_node
 from nodes.custom_nodes import CustomNodeManager
+from nodes.connection_selection_node import (
+    connection_selection_node,
+    validate_connection_input_node,
+    route_by_connection_type
+)
+from nodes.postgresql_connection_node import postgresql_connection_node
 from agents.sql_agent import SQLAgentManager
 from agents.tools import CacheManager
 from utils.database import create_sql_database
@@ -96,8 +102,8 @@ class AgentGraphManager:
             self.db = db
             self.db_id = self.object_manager.store_database(db)
 
-            # Cria agente SQL
-            self.sql_agent = SQLAgentManager(db)
+            # Cria agente SQL (modo padrão multi-tabela)
+            self.sql_agent = SQLAgentManager(db, single_table_mode=False, selected_table=None)
 
             # Armazena objetos no gerenciador
             self.agent_id = self.object_manager.store_sql_agent(self.sql_agent, self.db_id)
@@ -139,6 +145,15 @@ class AgentGraphManager:
             # Adiciona nós de validação e preparação
             workflow.add_node("validate_input", validate_query_input_node)
             workflow.add_node("check_cache", check_cache_node)
+
+            # Adiciona nós de conexão
+            workflow.add_node("connection_selection", connection_selection_node)
+            workflow.add_node("validate_connection", validate_connection_input_node)
+            workflow.add_node("postgresql_connection", postgresql_connection_node)
+            workflow.add_node("csv_processing", csv_processing_node)
+            workflow.add_node("create_database", create_database_from_dataframe_node)
+            workflow.add_node("load_database", load_existing_database_node)
+
             workflow.add_node("validate_processing", validate_processing_input_node)
             workflow.add_node("process_initial_context", process_initial_context_node)
             workflow.add_node("prepare_context", prepare_query_context_node)
@@ -165,22 +180,42 @@ class AgentGraphManager:
             # Fluxo principal
             workflow.add_edge("validate_input", "check_cache")
 
-            # Condicional para cache hit ou processing
+            # Condicional para cache hit ou processing/conexão
             workflow.add_conditional_edges(
                 "check_cache",
                 route_after_cache_check,
                 {
                     "update_history": "update_history",
                     "validate_processing": "validate_processing",
-                    "prepare_context": "prepare_context"
+                    "connection_selection": "connection_selection"
                 }
             )
 
             # Fluxo do Processing Agent
             workflow.add_edge("validate_processing", "process_initial_context")
             workflow.add_edge("process_initial_context", "prepare_context")
+            workflow.add_edge("prepare_context", "connection_selection")
+
+            # Fluxo de seleção de conexão
+            workflow.add_edge("connection_selection", "validate_connection")
+
+            # Roteamento por tipo de conexão (apenas se necessário)
+            workflow.add_conditional_edges(
+                "validate_connection",
+                route_by_connection_type,
+                {
+                    "postgresql_connection": "postgresql_connection",
+                    "csv_processing": "csv_processing",
+                    "load_database": "load_database",
+                    "get_db_sample": "get_db_sample"  # Pula conexão se já existe
+                }
+            )
 
-            workflow.add_edge("prepare_context", "get_db_sample")
+            # Fluxos específicos de conexão (apenas quando necessário)
+            workflow.add_edge("postgresql_connection", "get_db_sample")
+            workflow.add_edge("csv_processing", "create_database")
+            workflow.add_edge("create_database", "get_db_sample")
+            workflow.add_edge("load_database", "get_db_sample")
             workflow.add_edge("get_db_sample", "process_query")
 
             # Condicional para gráficos (após AgentSQL)
@@ -229,6 +264,10 @@ class AgentGraphManager:
         advanced_mode: bool = False,
         processing_enabled: bool = False,
         processing_model: str = "GPT-4o-mini",
+        connection_type: str = "csv",
+        postgresql_config: Optional[Dict] = None,
+        selected_table: str = None,
+        single_table_mode: bool = False,
         thread_id: str = "default"
     ) -> Dict[str, Any]:
         """
@@ -240,6 +279,10 @@ class AgentGraphManager:
             advanced_mode: Se deve usar refinamento avançado
             processing_enabled: Se deve usar o Processing Agent
             processing_model: Modelo para o Processing Agent
+            connection_type: Tipo de conexão ("csv" ou "postgresql")
+            postgresql_config: Configuração PostgreSQL (se aplicável)
+            selected_table: Tabela selecionada (para PostgreSQL)
+            single_table_mode: Se deve usar apenas uma tabela (PostgreSQL)
             thread_id: ID da thread para checkpoint
 
         Returns:
@@ -256,7 +299,7 @@ class AgentGraphManager:
                 if db_id:
                     db = self.object_manager.get_database(db_id)
                     if db:
-                        new_sql_agent = SQLAgentManager(db, selected_model)
+                        new_sql_agent = SQLAgentManager(db, selected_model, single_table_mode=False, selected_table=None)
                         self.agent_id = self.object_manager.store_sql_agent(new_sql_agent, db_id)
                         logging.info(f"Agente SQL recriado com sucesso para modelo {selected_model}")
                     else:
@@ -271,6 +314,12 @@ class AgentGraphManager:
             logging.info(f"[MAIN GRAPH] Advanced mode: {advanced_mode}")
             logging.info(f"[MAIN GRAPH] Processing enabled: {processing_enabled}")
             logging.info(f"[MAIN GRAPH] Processing model: {processing_model}")
+            logging.info(f"[MAIN GRAPH] Connection type: {connection_type}")
+            if postgresql_config:
+                logging.info(f"[MAIN GRAPH] PostgreSQL config: {postgresql_config['host']}:{postgresql_config['port']}/{postgresql_config['database']}")
+            if selected_table:
+                logging.info(f"[MAIN GRAPH] Selected table: {selected_table}")
+            logging.info(f"[MAIN GRAPH] Single table mode: {single_table_mode}")
 
             # Prepara estado inicial com IDs serializáveis
             initial_state = {
@@ -313,7 +362,15 @@ class AgentGraphManager:
                 "quality_metrics": None,
                 # Campos relacionados ao contexto SQL
                 "sql_context": None,
-                "sql_result": None
+                "sql_result": None,
+                # Campos relacionados ao tipo de conexão
+                "connection_type": connection_type,
+                "postgresql_config": postgresql_config,
+                "selected_table": selected_table,
+                "single_table_mode": single_table_mode,
+                "connection_success": self.db_id is not None,  # True se já tem conexão
+                "connection_error": None,
+                "connection_info": None
             }
             
             # Executa o grafo
@@ -372,10 +429,10 @@ class AgentGraphManager:
                 self.engine_id = db_result["engine_id"]
                 self.db_id = db_result["db_id"]
 
-                # Cria novo agente SQL
+                # Cria novo agente SQL (modo padrão multi-tabela)
                 new_engine = self.object_manager.get_engine(self.engine_id)
                 new_db = self.object_manager.get_database(self.db_id)
-                new_sql_agent = SQLAgentManager(new_db)
+                new_sql_agent = SQLAgentManager(new_db, single_table_mode=False, selected_table=None)
 
                 # Atualiza agente
                 self.agent_id = self.object_manager.store_sql_agent(new_sql_agent, self.db_id)
@@ -396,7 +453,79 @@ class AgentGraphManager:
                 "success": False,
                 "message": error_msg
             }
-    
+
+    async def handle_postgresql_connection(self, state: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Processa conexão PostgreSQL usando nova arquitetura de nós
+
+        Args:
+            state: Estado contendo configuração PostgreSQL
+
+        Returns:
+            Resultado da conexão
+        """
+        try:
+            # Adiciona campos necessários ao estado
+            state.update({
+                "success": False,
+                "message": "",
+                "connection_info": {},
+                "connection_error": None,
+                "connection_success": False
+            })
+
+            # Executa nó de conexão PostgreSQL
+            pg_result = await postgresql_connection_node(state)
+
+            if not pg_result["success"]:
+                return pg_result
+
+            # Atualiza sistema se conexão foi bem-sucedida
+            if pg_result["success"]:
+                # Atualiza IDs dos objetos
+                self.engine_id = pg_result["engine_id"]
+                self.db_id = pg_result["db_id"]
+
+                # Cria novo agente SQL com configurações do estado
+                new_engine = self.object_manager.get_engine(self.engine_id)
+                new_db = self.object_manager.get_database(self.db_id)
+
+                # Obtém configurações de tabela do estado
+                single_table_mode = state.get("single_table_mode", False)
+                selected_table = state.get("selected_table")
+                selected_model = state.get("selected_model", "gpt-4o-mini")
+
+                new_sql_agent = SQLAgentManager(
+                    new_db,
+                    selected_model,
+                    single_table_mode=single_table_mode,
+                    selected_table=selected_table
+                )
+
+                # Atualiza agente
+                self.agent_id = self.object_manager.store_sql_agent(new_sql_agent, self.db_id)
+
+                # Armazena metadados de conexão
+                connection_info = pg_result.get("connection_info", {})
+                self.object_manager.store_connection_metadata(self.db_id, connection_info)
+
+                # Limpa cache
+                cache_manager = self.object_manager.get_cache_manager(self.cache_id)
+                if cache_manager:
+                    cache_manager.clear_cache()
+
+                logging.info("[POSTGRESQL] Sistema atualizado com nova conexão PostgreSQL")
+
+            return pg_result
+
+        except Exception as e:
+            error_msg = f"❌ Erro na conexão PostgreSQL: {e}"
+            logging.error(error_msg)
+            return {
+                "success": False,
+                "message": error_msg
+            }
+
     async def reset_system(self) -> Dict[str, Any]:
         """
         Reseta o sistema ao estado inicial

nodes/agent_node.py

@@ -54,6 +54,15 @@ class AgentState(TypedDict):
     sql_context: Optional[str]  # Contexto preparado para o agente SQL
     sql_result: Optional[dict]  # Resultado do agente SQL
 
+    # Campos relacionados ao tipo de conexão
+    connection_type: str  # "csv" | "postgresql"
+    postgresql_config: Optional[dict]  # Configuração PostgreSQL
+    selected_table: Optional[str]  # Tabela selecionada (para PostgreSQL)
+    single_table_mode: bool  # Se deve usar apenas uma tabela (PostgreSQL)
+    connection_success: bool  # Se a conexão foi estabelecida com sucesso
+    connection_error: Optional[str]  # Erro na conexão
+    connection_info: Optional[dict]  # Informações da conexão estabelecida
+
 
 def should_refine_response(state: Dict[str, Any]) -> str:
     """
@@ -111,6 +120,8 @@ def route_after_cache_check(state: Dict[str, Any]) -> str:
     """
     Roteamento após verificação de cache
 
+    CACHE TEMPORARIAMENTE DESATIVADO - Sempre ignora cache hit
+
     Args:
         state: Estado atual
 
@@ -122,7 +133,11 @@ def route_after_cache_check(state: Dict[str, Any]) -> str:
     cache_hit = state.get("cache_hit", False)
     processing_enabled = state.get("processing_enabled", False)
 
-    logging.info(f"[ROUTING] Cache hit: {cache_hit}")
+    # DESATIVAÇÃO TEMPORÁRIA DO CACHE
+    # Força cache_hit = False para sempre processar queries
+    cache_hit = False
+
+    logging.info(f"[ROUTING] Cache hit: {cache_hit} (CACHE DESATIVADO TEMPORARIAMENTE)")
     logging.info(f"[ROUTING] Processing enabled: {processing_enabled}")
 
     if cache_hit:
@@ -132,5 +147,5 @@ def route_after_cache_check(state: Dict[str, Any]) -> str:
         logging.info("[ROUTING] Direcionando para validate_processing (processing habilitado)")
         return "validate_processing"
     else:
-        logging.info("[ROUTING] Direcionando para prepare_context (fluxo normal)")
-        return "prepare_context"
+        logging.info("[ROUTING] Direcionando para connection_selection (fluxo direto)")
+        return "connection_selection"

nodes/connection_selection_node.py

@@ -0,0 +1,161 @@
+"""
+Nó para seleção do tipo de conexão (csv ou postgresql)
+"""
+import logging
+from typing import Dict, Any
+from utils.validation import validate_connection_state
+
+
+async def connection_selection_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para determinar o tipo de conexão baseado na entrada do usuário
+    
+    Args:
+        state: Estado atual do agente
+        
+    Returns:
+        Estado atualizado com tipo de conexão definido
+    """
+    try:
+        logging.info("[CONNECTION_SELECTION] Iniciando seleção de tipo de conexão")
+        
+        # Verifica se o tipo de conexão já foi definido
+        connection_type = state.get("connection_type")
+        
+        if not connection_type:
+            # Se não foi definido, assume csv como padrão (compatibilidade)
+            connection_type = "csv"
+            logging.info("[CONNECTION_SELECTION] Tipo de conexão não definido, usando csv como padrão")
+        
+        # Valida tipo de conexão
+        valid_types = ["csv", "postgresql"]
+        if connection_type.upper() not in [t.upper() for t in valid_types]:
+            error_msg = f"Tipo de conexão inválido: {connection_type}. Tipos válidos: {valid_types}"
+            logging.error(f"[CONNECTION_SELECTION] {error_msg}")
+            state.update({
+                "connection_type": "csv",  # Fallback para csv
+                "connection_error": error_msg,
+                "connection_success": False
+            })
+            return state
+        
+        # Atualiza estado com tipo de conexão validado
+        state.update({
+            "connection_type": connection_type,
+            "connection_error": None,
+            "connection_success": True
+        })
+        
+        logging.info(f"[CONNECTION_SELECTION] Tipo de conexão selecionado: {connection_type}")
+        
+        return state
+        
+    except Exception as e:
+        error_msg = f"Erro na seleção de tipo de conexão: {e}"
+        logging.error(f"[CONNECTION_SELECTION] {error_msg}")
+        
+        # Fallback para csv em caso de erro
+        state.update({
+            "connection_type": "csv",
+            "connection_error": error_msg,
+            "connection_success": False
+        })
+        
+        return state
+
+
+def route_by_connection_type(state: Dict[str, Any]) -> str:
+    """
+    Função de roteamento baseada no tipo de conexão
+
+    Args:
+        state: Estado atual do agente
+
+    Returns:
+        Nome do próximo nó baseado no tipo de conexão
+    """
+    connection_type = state.get("connection_type", "csv")
+    file_path = state.get("file_path")
+    db_id = state.get("db_id")
+    engine_id = state.get("engine_id")
+
+    logging.info(f"[CONNECTION_ROUTING] Roteando para tipo: {connection_type}")
+    logging.info(f"[CONNECTION_ROUTING] DB ID existente: {db_id}")
+    logging.info(f"[CONNECTION_ROUTING] Engine ID existente: {engine_id}")
+
+    # Se já tem conexão estabelecida, pula para get_db_sample
+    # Verifica se o sistema já foi inicializado
+    from utils.object_manager import get_object_manager
+    obj_manager = get_object_manager()
+
+    # Verifica se há agentes SQL já criados (indicando sistema inicializado)
+    stats = obj_manager.get_stats()
+    has_sql_agents = stats.get("sql_agents", 0) > 0
+    has_databases = stats.get("databases", 0) > 0
+
+    if has_sql_agents and has_databases:
+        logging.info("[CONNECTION_ROUTING] Sistema já inicializado com agentes e bancos, pulando para get_db_sample")
+        return "get_db_sample"
+
+    # Fallback: verifica IDs específicos
+    if db_id and engine_id:
+        logging.info("[CONNECTION_ROUTING] Conexão já estabelecida via IDs, pulando para get_db_sample")
+        return "get_db_sample"
+
+    if connection_type.upper() == "POSTGRESQL":
+        return "postgresql_connection"
+    elif file_path:
+        # Há arquivo csv para processar
+        return "csv_processing"
+    else:
+        # Usar banco existente
+        return "load_database"
+
+
+async def validate_connection_input_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para validar entrada de conexão antes do processamento
+    
+    Args:
+        state: Estado atual do agente
+        
+    Returns:
+        Estado atualizado com validação
+    """
+    try:
+        logging.info("[CONNECTION_VALIDATION] Validando entrada de conexão")
+        
+        connection_type = state.get("connection_type", "csv")
+        
+        # Usa validação centralizada
+        is_valid, validation_error = validate_connection_state(state)
+
+        if not is_valid:
+            logging.error(f"[CONNECTION_VALIDATION] {validation_error}")
+            state.update({
+                "connection_error": validation_error,
+                "connection_success": False
+            })
+            return state
+            
+        logging.info(f"[CONNECTION_VALIDATION] Validação de conexão {connection_type} bem-sucedida")
+        
+        # Validação bem-sucedida
+        state.update({
+            "connection_error": None,
+            "connection_success": True
+        })
+        
+        logging.info("[CONNECTION_VALIDATION] Validação de conexão concluída com sucesso")
+        return state
+        
+    except Exception as e:
+        error_msg = f"Erro na validação de conexão: {e}"
+        logging.error(f"[CONNECTION_VALIDATION] {error_msg}")
+        
+        state.update({
+            "connection_error": error_msg,
+            "connection_success": False
+        })
+        
+        return state

nodes/custom_nodes.py

@@ -136,8 +136,8 @@ async def reset_system_node(state: Dict[str, Any]) -> Dict[str, Any]:
         engine = obj_manager.get_engine(db_result["engine_id"])
         db = obj_manager.get_object(db_result["db_id"])
 
-        # Recria agente SQL
-        sql_agent = SQLAgentManager(db)
+        # Recria agente SQL (modo padrão multi-tabela)
+        sql_agent = SQLAgentManager(db, single_table_mode=False, selected_table=None)
 
         # Atualiza objetos no gerenciador
         engine_id = obj_manager.store_engine(engine)

nodes/database_node.py

@@ -202,8 +202,63 @@ async def get_database_sample_node(state: Dict[str, Any]) -> Dict[str, Any]:
         if not engine:
             raise ValueError("Engine não encontrada")
         
+        # Determina qual tabela usar para amostra
+        connection_type = state.get("connection_type", "csv")
+
+        if connection_type == "postgresql":
+            # Para PostgreSQL, detecta dinamicamente a primeira tabela disponível com dados
+            import sqlalchemy as sa
+
+            try:
+                with engine.connect() as conn:
+                    # Obtém lista de tabelas disponíveis
+                    tables_result = conn.execute(sa.text("""
+                        SELECT table_name
+                        FROM information_schema.tables
+                        WHERE table_schema = 'public'
+                        ORDER BY table_name
+                    """))
+                    available_tables = [row[0] for row in tables_result.fetchall()]
+
+                    if not available_tables:
+                        raise ValueError("Nenhuma tabela encontrada no banco PostgreSQL")
+
+                    # Tenta encontrar uma tabela com dados
+                    table_name = None
+                    for table in available_tables:
+                        try:
+                            # Verifica se a tabela tem dados
+                            count_result = conn.execute(sa.text(f"SELECT COUNT(*) FROM {table} LIMIT 1"))
+                            count = count_result.scalar()
+                            if count > 0:
+                                table_name = table
+                                logging.info(f"[DATABASE] PostgreSQL - usando tabela '{table_name}' para amostra ({count} registros)")
+                                break
+                        except Exception as e:
+                            logging.warning(f"[DATABASE] Erro ao verificar tabela {table}: {e}")
+                            continue
+
+                    # Se nenhuma tabela tem dados, usa a primeira disponível
+                    if not table_name:
+                        table_name = available_tables[0]
+                        logging.info(f"[DATABASE] PostgreSQL - usando primeira tabela '{table_name}' (sem dados detectados)")
+
+            except Exception as e:
+                logging.error(f"[DATABASE] Erro ao detectar tabelas PostgreSQL: {e}")
+                raise ValueError(f"Erro ao acessar tabelas PostgreSQL: {e}")
+
+        else:
+            table_name = "tabela"  # Padrão para CSV
+            logging.info(f"[DATABASE] CSV - usando tabela padrão: {table_name}")
+
         # Obtém amostra dos dados
-        sample_df = pd.read_sql_query("SELECT * FROM tabela LIMIT 10", engine)
+        try:
+            sample_df = pd.read_sql_query(f"SELECT * FROM {table_name} LIMIT 10", engine)
+            logging.info(f"[DATABASE] Amostra obtida da tabela '{table_name}': {sample_df.shape[0]} registros")
+        except Exception as e:
+            logging.error(f"[DATABASE] Erro ao obter amostra da tabela '{table_name}': {e}")
+            # Se falhar, cria DataFrame vazio para não quebrar o fluxo
+            sample_df = pd.DataFrame()
         
         # Converte para formato serializável
         db_sample_dict = {

nodes/postgresql_connection_node.py

@@ -0,0 +1,293 @@
+"""
+Nó para conexão com PostgreSQL
+"""
+import logging
+import time
+from typing import Dict, Any, Optional
+from sqlalchemy import create_engine, text
+from langchain_community.utilities import SQLDatabase
+
+from utils.database import create_sql_database
+from utils.object_manager import get_object_manager
+from utils.validation import (
+    validate_postgresql_config,
+    sanitize_postgresql_config,
+    get_connection_error_message
+)
+
+
+async def postgresql_connection_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para estabelecer conexão com PostgreSQL
+    
+    Args:
+        state: Estado atual do agente
+        
+    Returns:
+        Estado atualizado com conexão PostgreSQL estabelecida
+    """
+    try:
+        logging.info("[POSTGRESQL_CONNECTION] Iniciando conexão com PostgreSQL")
+        
+        # Recupera e valida configuração PostgreSQL
+        postgresql_config = state.get("postgresql_config", {})
+
+        if not postgresql_config:
+            error_msg = "Configuração PostgreSQL não encontrada"
+            logging.error(f"[POSTGRESQL_CONNECTION] {error_msg}")
+            state.update({
+                "success": False,
+                "message": f"❌ {error_msg}",
+                "connection_error": error_msg,
+                "connection_success": False
+            })
+            return state
+
+        # Sanitiza e valida configuração
+        postgresql_config = sanitize_postgresql_config(postgresql_config)
+        is_valid, validation_error = validate_postgresql_config(postgresql_config)
+
+        if not is_valid:
+            error_msg = f"Configuração PostgreSQL inválida: {validation_error}"
+            logging.error(f"[POSTGRESQL_CONNECTION] {error_msg}")
+            state.update({
+                "success": False,
+                "message": f"❌ {validation_error}",
+                "connection_error": error_msg,
+                "connection_success": False
+            })
+            return state
+        
+        # Extrai credenciais
+        host = postgresql_config.get("host")
+        port = postgresql_config.get("port", 5432)
+        database = postgresql_config.get("database")
+        username = postgresql_config.get("username")
+        password = postgresql_config.get("password")
+        
+        # Constrói URI de conexão
+        connection_uri = f"postgresql+psycopg2://{username}:{password}@{host}:{port}/{database}"
+        
+        logging.info(f"[POSTGRESQL_CONNECTION] Conectando a: {host}:{port}/{database}")
+        
+        # Tenta estabelecer conexão
+        start_time = time.time()
+        
+        try:
+            # Cria engine SQLAlchemy
+            engine = create_engine(
+                connection_uri,
+                pool_timeout=30,
+                pool_recycle=3600,
+                echo=False  # Não mostrar SQL queries no log
+            )
+            
+            # Testa conexão
+            with engine.connect() as conn:
+                result = conn.execute(text("SELECT 1"))
+                result.fetchone()
+            
+            connection_time = time.time() - start_time
+            logging.info(f"[POSTGRESQL_CONNECTION] Conexão estabelecida em {connection_time:.2f}s")
+            
+        except Exception as conn_error:
+            error_msg = f"Falha na conexão PostgreSQL: {str(conn_error)}"
+            logging.error(f"[POSTGRESQL_CONNECTION] {error_msg}")
+
+            # Usa função de tratamento de erro amigável
+            user_error = get_connection_error_message(conn_error)
+            
+            state.update({
+                "success": False,
+                "message": user_error,
+                "connection_error": error_msg,
+                "connection_success": False
+            })
+            return state
+        
+        # Cria objeto SQLDatabase do LangChain (sempre com todas as tabelas para amostra)
+        try:
+            db = SQLDatabase.from_uri(connection_uri)
+            logging.info("[POSTGRESQL_CONNECTION] SQLDatabase criado com sucesso")
+
+            # Obtém informações do banco
+            table_names = db.get_usable_table_names()
+            logging.info(f"[POSTGRESQL_CONNECTION] Tabelas encontradas: {table_names}")
+
+            if not table_names:
+                warning_msg = "⚠️ Nenhuma tabela encontrada no banco de dados"
+                logging.warning(f"[POSTGRESQL_CONNECTION] {warning_msg}")
+                # Não é um erro fatal, mas avisa o usuário
+            
+        except Exception as db_error:
+            error_msg = f"Erro ao criar SQLDatabase: {str(db_error)}"
+            logging.error(f"[POSTGRESQL_CONNECTION] {error_msg}")
+            state.update({
+                "success": False,
+                "message": f"❌ {error_msg}",
+                "connection_error": error_msg,
+                "connection_success": False
+            })
+            return state
+        
+        # Armazena objetos no ObjectManager
+        obj_manager = get_object_manager()
+        engine_id = obj_manager.store_engine(engine)
+        db_id = obj_manager.store_database(db)
+        
+        # Informações da conexão
+        connection_info = {
+            "type": "postgresql",
+            "host": host,
+            "port": port,
+            "database": database,
+            "username": username,
+            "table_count": len(table_names),
+            "tables": table_names[:10],  # Primeiras 10 tabelas
+            "connection_time": connection_time,
+            "engine_id": engine_id,
+            "db_id": db_id
+        }
+        
+        # Atualiza estado com sucesso
+        state.update({
+            "success": True,
+            "message": f"✅ Conectado ao PostgreSQL: {len(table_names)} tabelas encontradas",
+            "connection_info": connection_info,
+            "connection_error": None,
+            "connection_success": True,
+            "engine_id": engine_id,
+            "db_id": db_id
+        })
+        
+        logging.info(f"[POSTGRESQL_CONNECTION] Conexão PostgreSQL estabelecida com sucesso")
+        logging.info(f"[POSTGRESQL_CONNECTION] Informações: {connection_info}")
+        
+        return state
+        
+    except Exception as e:
+        error_msg = f"Erro inesperado na conexão PostgreSQL: {e}"
+        logging.error(f"[POSTGRESQL_CONNECTION] {error_msg}")
+        
+        state.update({
+            "success": False,
+            "message": f"❌ {error_msg}",
+            "connection_error": error_msg,
+            "connection_success": False
+        })
+        
+        return state
+
+
+def validate_postgresql_credentials(postgresql_config: Dict[str, Any]) -> tuple[bool, Optional[str]]:
+    """
+    Valida credenciais PostgreSQL sem estabelecer conexão completa
+    
+    Args:
+        postgresql_config: Configuração PostgreSQL
+        
+    Returns:
+        Tupla (válido, mensagem_erro)
+    """
+    try:
+        required_fields = ["host", "port", "database", "username", "password"]
+        
+        for field in required_fields:
+            if not postgresql_config.get(field):
+                return False, f"Campo obrigatório ausente: {field}"
+        
+        # Validações básicas
+        port = postgresql_config.get("port")
+        try:
+            port_int = int(port)
+            if port_int < 1 or port_int > 65535:
+                return False, "Porta deve estar entre 1 e 65535"
+        except (ValueError, TypeError):
+            return False, "Porta deve ser um número válido"
+        
+        host = postgresql_config.get("host", "").strip()
+        if not host:
+            return False, "Host não pode estar vazio"
+        
+        database = postgresql_config.get("database", "").strip()
+        if not database:
+            return False, "Nome do banco não pode estar vazio"
+        
+        username = postgresql_config.get("username", "").strip()
+        if not username:
+            return False, "Nome de usuário não pode estar vazio"
+        
+        return True, None
+        
+    except Exception as e:
+        return False, f"Erro na validação: {e}"
+
+
+async def test_postgresql_connection_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para testar conexão PostgreSQL sem armazenar
+    
+    Args:
+        state: Estado atual do agente
+        
+    Returns:
+        Estado atualizado com resultado do teste
+    """
+    try:
+        logging.info("[POSTGRESQL_TEST] Testando conexão PostgreSQL")
+        
+        postgresql_config = state.get("postgresql_config", {})
+        
+        # Valida credenciais
+        is_valid, error_msg = validate_postgresql_credentials(postgresql_config)
+        if not is_valid:
+            state.update({
+                "test_success": False,
+                "test_message": f"❌ {error_msg}",
+                "test_error": error_msg
+            })
+            return state
+        
+        # Testa conexão rápida
+        host = postgresql_config.get("host")
+        port = postgresql_config.get("port", 5432)
+        database = postgresql_config.get("database")
+        username = postgresql_config.get("username")
+        password = postgresql_config.get("password")
+        
+        connection_uri = f"postgresql+psycopg2://{username}:{password}@{host}:{port}/{database}"
+        
+        try:
+            engine = create_engine(connection_uri, pool_timeout=10)
+            with engine.connect() as conn:
+                conn.execute(text("SELECT 1"))
+            
+            state.update({
+                "test_success": True,
+                "test_message": "✅ Conexão PostgreSQL testada com sucesso",
+                "test_error": None
+            })
+            
+        except Exception as e:
+            error_msg = f"Falha no teste de conexão: {str(e)}"
+            state.update({
+                "test_success": False,
+                "test_message": f"❌ {error_msg}",
+                "test_error": error_msg
+            })
+        
+        return state
+        
+    except Exception as e:
+        error_msg = f"Erro no teste de conexão: {e}"
+        logging.error(f"[POSTGRESQL_TEST] {error_msg}")
+        
+        state.update({
+            "test_success": False,
+            "test_message": f"❌ {error_msg}",
+            "test_error": error_msg
+        })
+        
+        return state
+
+

nodes/processing_node.py

@@ -41,46 +41,120 @@ async def process_initial_context_node(state: Dict[str, Any]) -> Dict[str, Any]:
             logging.warning("[PROCESSING NODE] Entrada do usuário não disponível")
             return state
         
-        # Acessa diretamente o banco de dados para criar amostra
+        # Acessa o banco de dados correto baseado no estado atual
         obj_manager = get_object_manager()
 
-        # Usa os IDs do GraphManager (que são globais)
         try:
-            # Acessa diretamente os IDs do GraphManager através do ObjectManager
-            # Pega o primeiro engine e database disponíveis (assumindo que há apenas um)
-            engines = obj_manager._engines
-            databases = obj_manager._databases
-
-            if not engines or not databases:
-                logging.error("[PROCESSING NODE] Nenhum engine ou database encontrado no ObjectManager")
+            # Usa os IDs específicos do estado atual (não o primeiro disponível)
+            engine_id = state.get("engine_id")
+            db_id = state.get("db_id")
+
+            logging.info(f"[PROCESSING NODE] ===== DEBUG ESTADO =====")
+            logging.info(f"[PROCESSING NODE] engine_id do estado: {engine_id}")
+            logging.info(f"[PROCESSING NODE] db_id do estado: {db_id}")
+            logging.info(f"[PROCESSING NODE] connection_type do estado: {state.get('connection_type')}")
+            logging.info(f"[PROCESSING NODE] Chaves disponíveis no estado: {list(state.keys())}")
+            logging.info(f"[PROCESSING NODE] ===== FIM DEBUG =====")
+
+            if not engine_id or not db_id:
+                logging.error("[PROCESSING NODE] IDs de engine ou database não encontrados no estado")
+                logging.error(f"[PROCESSING NODE] engine_id: {engine_id}, db_id: {db_id}")
+
+                # Fallback: tenta usar os IDs disponíveis no ObjectManager
+                logging.info("[PROCESSING NODE] Tentando fallback para IDs disponíveis...")
+                engines = obj_manager._engines
+                databases = obj_manager._databases
+
+                if engines and databases:
+                    engine_id = list(engines.keys())[-1]  # Pega o último (mais recente)
+                    db_id = list(databases.keys())[-1]    # Pega o último (mais recente)
+                    logging.info(f"[PROCESSING NODE] Fallback: usando engine_id={engine_id}, db_id={db_id}")
+                else:
+                    logging.error("[PROCESSING NODE] Nenhum engine ou database disponível no ObjectManager")
+                    return state
+
+            # Obtém engine e database específicos do estado atual
+            engine = obj_manager.get_engine(engine_id)
+            database = obj_manager.get_database(db_id)
+
+            logging.info(f"[PROCESSING NODE] Engine obtido: {engine is not None}")
+            logging.info(f"[PROCESSING NODE] Database obtido: {database is not None}")
+
+            if not engine or not database:
+                logging.error("[PROCESSING NODE] Engine ou database não encontrados no ObjectManager")
+                logging.error(f"[PROCESSING NODE] engine: {engine}, database: {database}")
+                logging.error(f"[PROCESSING NODE] Engines disponíveis: {list(obj_manager._engines.keys())}")
+                logging.error(f"[PROCESSING NODE] Databases disponíveis: {list(obj_manager._databases.keys())}")
                 return state
 
-            # Pega o primeiro engine e database disponíveis
-            engine_id = list(engines.keys())[0]
-            db_id = list(databases.keys())[0]
-
-            engine = engines[engine_id]
-            database = databases[db_id]
-
-            logging.info(f"[PROCESSING NODE] Usando engine {engine_id} e database {db_id}")
-
-            # Cria amostra diretamente do banco
+            logging.info(f"[PROCESSING NODE] Usando engine {engine_id} e database {db_id} do estado atual")
+
+            # Detecta o tipo de engine baseado no dialect
+            engine_dialect = str(engine.dialect.name).lower()
+            connection_type = state.get("connection_type", "csv")
+            single_table_mode = state.get("single_table_mode", False)
+            selected_table = state.get("selected_table")
+
+            logging.info(f"[PROCESSING NODE] ===== DETECÇÃO DE CONEXÃO =====")
+            logging.info(f"[PROCESSING NODE] Engine dialect detectado: {engine_dialect}")
+            logging.info(f"[PROCESSING NODE] Connection type do estado: {connection_type}")
+            logging.info(f"[PROCESSING NODE] Single table mode: {single_table_mode}")
+            logging.info(f"[PROCESSING NODE] Selected table: {selected_table}")
+            logging.info(f"[PROCESSING NODE] Engine URL: {str(engine.url)}")
+            logging.info(f"[PROCESSING NODE] ===== FIM DETECÇÃO =====")
+
+            # Validação: engine dialect deve corresponder ao connection_type
+            if connection_type.lower() == "postgresql" and engine_dialect != "postgresql":
+                logging.error(f"[PROCESSING NODE] INCONSISTÊNCIA: connection_type={connection_type} mas engine_dialect={engine_dialect}")
+                logging.error(f"[PROCESSING NODE] Isso indica que está usando o engine errado!")
+            elif connection_type.lower() == "csv" and engine_dialect != "sqlite":
+                logging.error(f"[PROCESSING NODE] INCONSISTÊNCIA: connection_type={connection_type} mas engine_dialect={engine_dialect}")
+                logging.error(f"[PROCESSING NODE] Isso indica que está usando o engine errado!")
+
+            # NOVA IMPLEMENTAÇÃO: Cria dados das colunas baseado no tipo de conexão
+            columns_data = {}
             import sqlalchemy as sa
-            with engine.connect() as conn:
-                # Obtém amostra de dados (10 linhas)
-                result = conn.execute(sa.text("SELECT * FROM tabela LIMIT 10"))
-                columns = result.keys()
-                rows = result.fetchall()
 
-                # Converte para DataFrame
-                db_sample = pd.DataFrame(rows, columns=columns)
+            if engine_dialect == "postgresql":
+                # Para PostgreSQL, processa baseado no modo
+                if single_table_mode and selected_table:
+                    # Modo tabela única - processa APENAS a tabela selecionada
+                    logging.info(f"[PROCESSING NODE] PostgreSQL - Modo tabela única: {selected_table}")
+                    columns_data[selected_table] = _extract_table_columns_info(engine, selected_table)
+
+                else:
+                    # Modo multi-tabela - processa TODAS as tabelas disponíveis
+                    logging.info(f"[PROCESSING NODE] PostgreSQL - Modo multi-tabela")
+
+                    # Obtém lista de todas as tabelas
+                    with engine.connect() as conn:
+                        tables_result = conn.execute(sa.text("""
+                            SELECT table_name
+                            FROM information_schema.tables
+                            WHERE table_schema = 'public'
+                            ORDER BY table_name
+                        """))
+                        available_tables = [row[0] for row in tables_result.fetchall()]
+
+                    logging.info(f"[PROCESSING NODE] Tabelas encontradas: {available_tables}")
+
+                    # Processa cada tabela (máximo 5 para performance)
+                    for table_name in available_tables[:10]:
+                        columns_data[table_name] = _extract_table_columns_info(engine, table_name)
+
+            else:
+                # Para SQLite (CSV convertido), processa tabela padrão
+                logging.info(f"[PROCESSING NODE] SQLite - processando tabela padrão")
+                columns_data["tabela"] = _extract_table_columns_info(engine, "tabela")
 
-                logging.info(f"[PROCESSING NODE] Amostra criada diretamente do banco: {db_sample.shape[0]} linhas, {db_sample.shape[1]} colunas")
-                logging.info(f"[PROCESSING NODE] Colunas: {list(db_sample.columns)}")
+            logging.info(f"[PROCESSING NODE] ✅ Dados das colunas extraídos para {len(columns_data)} tabela(s)")
 
         except Exception as e:
-            logging.error(f"[PROCESSING NODE] Erro ao acessar banco de dados: {e}")
+            logging.error(f"[PROCESSING NODE] ❌ Erro ao acessar banco de dados: {e}")
             logging.error(f"[PROCESSING NODE] Detalhes do erro: {str(e)}")
+            logging.error(f"[PROCESSING NODE] Tipo do erro: {type(e)}")
+            import traceback
+            logging.error(f"[PROCESSING NODE] Traceback: {traceback.format_exc()}")
             return state
         
         # Recupera ou cria Processing Agent
@@ -102,15 +176,44 @@ async def process_initial_context_node(state: Dict[str, Any]) -> Dict[str, Any]:
             state["processing_agent_id"] = processing_agent_id
             logging.info(f"[PROCESSING NODE] Novo Processing Agent criado e armazenado com ID: {processing_agent_id}")
         
-        # Prepara contexto para o Processing Agent
-        processing_context = prepare_processing_context(user_input, db_sample)
+        # Prepara contexto para o Processing Agent com dados já processados
+        connection_type = state.get("connection_type", "csv")
+        single_table_mode = state.get("single_table_mode", False)
+        selected_table = state.get("selected_table")
+
+        # Obtém lista de tabelas disponíveis se for PostgreSQL
+        available_tables = None
+        if engine_dialect == "postgresql":
+            available_tables = list(columns_data.keys())
+            logging.info(f"[PROCESSING NODE] Tabelas disponíveis para contexto: {available_tables}")
+
+        # NOVA CHAMADA: Passa dados já processados em vez de fazer consultas redundantes
+        processing_context = prepare_processing_context(
+            user_input,
+            columns_data,  # Dados já processados das colunas
+            connection_type,
+            single_table_mode,
+            selected_table,
+            available_tables
+        )
 
         logging.info(f"[PROCESSING NODE] ===== CONTEXTO PARA PRIMEIRA LLM =====")
         logging.info(f"{processing_context}")
         logging.info(f"[PROCESSING NODE] ===== FIM DO CONTEXTO =====")
-        
+
         # Executa processamento
-        processing_result = await processing_agent.process_context(processing_context)
+        logging.info(f"[PROCESSING NODE] 🚀 Iniciando execução do Processing Agent...")
+        logging.info(f"[PROCESSING NODE] Processing Agent: {processing_agent}")
+        logging.info(f"[PROCESSING NODE] Modelo: {processing_agent.model_name if processing_agent else 'N/A'}")
+
+        try:
+            processing_result = await processing_agent.process_context(processing_context)
+            logging.info(f"[PROCESSING NODE] ✅ Processing Agent executado com sucesso")
+        except Exception as e:
+            logging.error(f"[PROCESSING NODE] ❌ Erro na execução do Processing Agent: {e}")
+            import traceback
+            logging.error(f"[PROCESSING NODE] Traceback: {traceback.format_exc()}")
+            return state
 
         # Log da resposta da primeira LLM
         logging.info(f"[PROCESSING NODE] ===== RESPOSTA DA PRIMEIRA LLM =====")
@@ -228,3 +331,147 @@ async def validate_processing_input_node(state: Dict[str, Any]) -> Dict[str, Any
         state["processing_enabled"] = False
 
     return state
+
+
+def _extract_table_columns_info(engine, table_name: str) -> list:
+    """
+    Extrai informações das colunas de uma tabela específica
+
+    Args:
+        engine: Engine SQLAlchemy
+        table_name: Nome da tabela
+
+    Returns:
+        Lista de dicionários com informações das colunas
+    """
+    import sqlalchemy as sa
+    import pandas as pd
+
+    try:
+        logging.info(f"[PROCESSING NODE] Extraindo informações da tabela: {table_name}")
+
+        with engine.connect() as conn:
+            # Primeiro, tenta obter dados da tabela (máximo 5 linhas)
+            try:
+                result = conn.execute(sa.text(f"SELECT * FROM {table_name} LIMIT 5"))
+                columns = result.keys()
+                rows = result.fetchall()
+
+                if rows:
+                    # Tabela com dados - processa normalmente
+                    table_df = pd.DataFrame(rows, columns=columns)
+                    columns_info = []
+
+                    for col in table_df.columns:
+                        col_data = table_df[col].dropna()
+
+                        col_info = {
+                            "column": col,
+                            "type": str(col_data.dtype) if len(col_data) > 0 else "object",
+                            "examples": "",
+                            "stats": ""
+                        }
+
+                        if len(col_data) > 0:
+                            # Adiciona exemplos de valores
+                            unique_values = col_data.unique()[:3]
+                            col_info["examples"] = ", ".join([str(v) for v in unique_values])
+
+                            # Adiciona estatísticas para colunas numéricas
+                            if col_data.dtype in ['int64', 'float64']:
+                                try:
+                                    min_val = col_data.min()
+                                    max_val = col_data.max()
+                                    col_info["stats"] = f" | Min: {min_val}, Max: {max_val}"
+                                except:
+                                    pass
+
+                        columns_info.append(col_info)
+
+                    logging.info(f"[PROCESSING NODE] ✅ Tabela {table_name}: {len(columns_info)} colunas com dados")
+                    return columns_info
+
+                else:
+                    # Tabela sem dados - obtém apenas estrutura das colunas
+                    logging.info(f"[PROCESSING NODE] ⚠️ Tabela {table_name} sem dados - obtendo apenas estrutura")
+
+                    # Para PostgreSQL, obtém informações das colunas do schema
+                    if str(engine.dialect.name).lower() == "postgresql":
+                        schema_result = conn.execute(sa.text(f"""
+                            SELECT column_name, data_type
+                            FROM information_schema.columns
+                            WHERE table_name = '{table_name}'
+                            ORDER BY ordinal_position
+                        """))
+
+                        columns_info = []
+                        for row in schema_result.fetchall():
+                            col_info = {
+                                "column": row[0],
+                                "type": row[1],
+                                "examples": "(sem dados)",
+                                "stats": ""
+                            }
+                            columns_info.append(col_info)
+                    else:
+                        # Para SQLite, usa PRAGMA
+                        pragma_result = conn.execute(sa.text(f"PRAGMA table_info({table_name})"))
+                        columns_info = []
+                        for row in pragma_result.fetchall():
+                            col_info = {
+                                "column": row[1],  # column name
+                                "type": row[2],    # column type
+                                "examples": "(sem dados)",
+                                "stats": ""
+                            }
+                            columns_info.append(col_info)
+
+                    logging.info(f"[PROCESSING NODE] ✅ Tabela {table_name}: {len(columns_info)} colunas (estrutura apenas)")
+                    return columns_info
+
+            except Exception as e:
+                # Se falhar ao acessar a tabela, tenta obter pelo menos a estrutura
+                logging.warning(f"[PROCESSING NODE] Erro ao acessar dados da tabela {table_name}: {e}")
+
+                try:
+                    # Fallback: obtém estrutura das colunas
+                    if str(engine.dialect.name).lower() == "postgresql":
+                        schema_result = conn.execute(sa.text(f"""
+                            SELECT column_name, data_type
+                            FROM information_schema.columns
+                            WHERE table_name = '{table_name}'
+                            ORDER BY ordinal_position
+                        """))
+
+                        columns_info = []
+                        for row in schema_result.fetchall():
+                            col_info = {
+                                "column": row[0],
+                                "type": row[1],
+                                "examples": "(erro ao acessar dados)",
+                                "stats": ""
+                            }
+                            columns_info.append(col_info)
+                    else:
+                        # Para SQLite
+                        pragma_result = conn.execute(sa.text(f"PRAGMA table_info({table_name})"))
+                        columns_info = []
+                        for row in pragma_result.fetchall():
+                            col_info = {
+                                "column": row[1],
+                                "type": row[2],
+                                "examples": "(erro ao acessar dados)",
+                                "stats": ""
+                            }
+                            columns_info.append(col_info)
+
+                    logging.info(f"[PROCESSING NODE] ⚠️ Tabela {table_name}: {len(columns_info)} colunas (fallback)")
+                    return columns_info
+
+                except Exception as e2:
+                    logging.error(f"[PROCESSING NODE] ❌ Erro total ao processar tabela {table_name}: {e2}")
+                    return []
+
+    except Exception as e:
+        logging.error(f"[PROCESSING NODE] ❌ Erro ao extrair informações da tabela {table_name}: {e}")
+        return []

nodes/query_node.py

@@ -55,8 +55,9 @@ async def process_user_query_node(state: Dict[str, Any]) -> Dict[str, Any]:
         cache_id = state.get("cache_id")
         cache_manager = obj_manager.get_cache_manager(cache_id) if cache_id else None
         
+        # CACHE TEMPORARIAMENTE DESATIVADO
         # Verifica cache se disponível
-        if cache_manager:
+        if False:  # cache_manager:
             cached_response = cache_manager.get_cached_response(user_input)
             if cached_response:
                 logging.info(f"[CACHE] Retornando resposta do cache")
@@ -108,10 +109,38 @@ async def process_user_query_node(state: Dict[str, Any]) -> Dict[str, Any]:
         agent_id = state.get("agent_id")
         if not agent_id:
             raise ValueError("ID do agente SQL não encontrado")
-        
+
         sql_agent = obj_manager.get_sql_agent(agent_id)
         if not sql_agent:
             raise ValueError("Agente SQL não encontrado")
+
+        # Verifica se precisa recriar o agente SQL para PostgreSQL com configurações atuais
+        connection_type = state.get("connection_type", "csv")
+        if connection_type == "postgresql":
+            single_table_mode = state.get("single_table_mode", False)
+            selected_table = state.get("selected_table")
+            selected_model = state.get("selected_model", "gpt-4o-mini")
+
+            # Verifica se as configurações mudaram
+            current_single_mode = getattr(sql_agent, 'single_table_mode', False)
+            current_table = getattr(sql_agent, 'selected_table', None)
+            current_model = getattr(sql_agent, 'model_name', 'gpt-4o-mini')
+
+            if (single_table_mode != current_single_mode or
+                selected_table != current_table or
+                selected_model != current_model):
+
+                logging.info(f"[QUERY] Recriando agente SQL - Modo: {'único' if single_table_mode else 'multi'}, Tabela: {selected_table}")
+
+                # Recria o agente com as novas configurações
+                sql_agent.recreate_agent(
+                    single_table_mode=single_table_mode,
+                    selected_table=selected_table,
+                    new_model=selected_model
+                )
+
+                # Atualiza no ObjectManager
+                obj_manager.store_sql_agent(sql_agent, state.get("db_id"))
         
         # Executa query no agente SQL com contexto direto
         sql_result = await sql_agent.execute_query(state["sql_context"])

requirements.txt

@@ -3,6 +3,7 @@ langgraph>=0.2.0
 langchain>=0.3.0
 langchain-openai>=0.2.0
 langchain-anthropic>=0.2.0
+langchain-google-genai>=2.0.0
 langchain-community>=0.3.0
 langchain-core>=0.3.0
 
@@ -13,6 +14,7 @@ langsmith>=0.1.39
 pandas>=2.0.0
 sqlalchemy>=2.0.0
 numpy>=1.24.0
+psycopg2-binary>=2.9.0
 
 # AI/ML Libraries
 huggingface_hub>=0.20.0

testes/README.md

@@ -0,0 +1,275 @@
+# 🧪 Sistema de Testes Massivos - AgentGraph
+
+Sistema completo para testes de consistência e performance dos agentes SQL com paralelismo otimizado.
+
+## 🎯 **Funcionalidades**
+
+### **✅ Configuração Dinâmica**
+- **Pergunta personalizada**: Define a query que será testada
+- **Múltiplos grupos**: Diferentes configurações de modelos
+- **Processing Agent**: Ativa/desativa com modelo específico
+- **Iterações configuráveis**: 1-100 testes por grupo
+
+### **⚡ Execução Paralela**
+- **Paralelismo otimizado**: Até 8 workers simultâneos
+- **Controle de recursos**: Semáforos para evitar sobrecarga
+- **Progress tracking**: Acompanhamento em tempo real
+- **Estimativa de tempo**: Tempo restante calculado dinamicamente
+
+### **🔍 Validação Inteligente**
+- **Validação LLM**: Análise automática com GPT/Claude
+- **Validação por palavra-chave**: Busca por conteúdo específico
+- **Pontuação 0-100**: Score detalhado de qualidade
+- **Análise de consistência**: Taxa de respostas similares
+
+### **📊 Relatórios Completos**
+- **Dashboard interativo**: Visualização em tempo real
+- **Múltiplas abas**: Resumo, grupos, resultados individuais
+- **Exportação Excel**: Relatórios detalhados em XLSX
+- **Métricas avançadas**: Taxa de acerto, consistência, performance
+
+## 🚀 **Como Usar**
+
+### **1. Instalação**
+```bash
+# Instalar dependências
+pip install -r testes/requirements.txt
+
+# Verificar configuração do AgentGraph
+python -c "from utils.config import validate_config; validate_config()"
+```
+
+### **2. Inicialização**
+```bash
+# IMPORTANTE: Execute da raiz do projeto!
+# Método 1: Script automático (RECOMENDADO)
+python run_massive_tests.py
+
+# Método 2: Direto (apenas se necessário)
+python testes/app_teste.py
+```
+
+### **3. Acesso**
+- **URL**: http://localhost:5001
+- **Interface**: HTML responsiva
+- **Compatibilidade**: Todos os navegadores modernos
+
+## 📋 **Fluxo de Uso**
+
+### **Passo 1: Configurar Pergunta**
+```
+1. Digite a pergunta que será testada
+2. Clique em "Criar Sessão"
+3. Sessão será criada com ID único
+```
+
+### **Passo 2: Adicionar Grupos**
+```
+1. Selecione modelo do SQL Agent
+2. Ative Processing Agent (opcional)
+3. Escolha modelo do Processing Agent
+4. Defina número de iterações (1-100)
+5. Clique em "Adicionar Grupo"
+6. Repita para criar múltiplos grupos
+```
+
+### **Passo 3: Configurar Validação**
+```
+Método LLM (Recomendado):
+- Análise automática da qualidade
+- Pontuação 0-100
+- Razão detalhada
+
+Método Palavra-chave:
+- Busca por texto específico
+- Validação binária (contém/não contém)
+```
+
+### **Passo 4: Executar Testes**
+```
+1. Clique em "Executar Testes"
+2. Acompanhe progresso em tempo real
+3. Visualize métricas durante execução
+4. Aguarde conclusão automática
+```
+
+### **Passo 5: Analisar Resultados**
+```
+Aba Resumo:
+- Métricas gerais
+- Melhor grupo
+- Grupo mais consistente
+
+Aba Por Grupo:
+- Taxa de sucesso por grupo
+- Comparação de modelos
+- Performance detalhada
+
+Aba Individual:
+- Cada teste executado
+- Detalhes completos
+- Query SQL gerada
+```
+
+## 📊 **Métricas Calculadas**
+
+### **Taxa de Sucesso**
+- **Cálculo**: (Testes sem erro / Total de testes) × 100
+- **Indica**: Estabilidade do modelo
+- **Ideal**: > 90%
+
+### **Taxa de Validação**
+- **Cálculo**: (Respostas válidas / Total de testes) × 100
+- **Indica**: Qualidade das respostas
+- **Ideal**: > 80%
+
+### **Consistência de Resposta**
+- **Cálculo**: (Respostas idênticas / Total de respostas) × 100
+- **Indica**: Determinismo do modelo
+- **Ideal**: > 70%
+
+### **Consistência SQL**
+- **Cálculo**: (Queries idênticas / Total de queries) × 100
+- **Indica**: Estabilidade da geração SQL
+- **Ideal**: > 80%
+
+### **Tempo Médio**
+- **Cálculo**: Soma dos tempos / Número de testes
+- **Indica**: Performance do modelo
+- **Ideal**: < 10s
+
+## 🔧 **Configurações Avançadas**
+
+### **Paralelismo**
+```python
+# Em test_runner.py
+max_workers = 8  # Ajuste conforme sua máquina
+```
+
+### **Validação LLM**
+```python
+# Em test_validator.py
+validator_model = "gpt-4o-mini"  # Modelo para validação
+temperature = 0.1  # Baixa para consistência
+```
+
+### **Timeouts**
+```python
+# Em app_teste.py
+status_polling = 2000  # ms entre verificações
+```
+
+## 📁 **Estrutura de Arquivos**
+
+```
+testes/
+├── app_teste.py              # Servidor Flask principal
+├── test_runner.py            # Executor de testes paralelos
+├── test_validator.py         # Sistema de validação
+├── report_generator.py       # Gerador de relatórios
+├── run_tests.py             # Script de inicialização
+├── requirements.txt         # Dependências
+├── README.md               # Esta documentação
+├── templates/
+│   └── index.html          # Interface HTML
+├── static/
+│   └── js/
+│       └── app.js          # JavaScript da interface
+└── reports/                # Relatórios gerados
+    ├── *.xlsx             # Relatórios Excel
+    ├── *.json             # Dados brutos
+    └── *.html             # Resumos HTML
+```
+
+## 🎯 **Casos de Uso**
+
+### **Comparação de Modelos**
+```
+Objetivo: Qual modelo SQL é mais consistente?
+Configuração:
+- Grupo 1: GPT-4o + Processing Agent
+- Grupo 2: Claude-3.5-Sonnet + Processing Agent  
+- Grupo 3: GPT-4o sem Processing Agent
+- 20 iterações cada
+```
+
+### **Impacto do Processing Agent**
+```
+Objetivo: Processing Agent melhora a qualidade?
+Configuração:
+- Grupo 1: GPT-4o-mini COM Processing Agent
+- Grupo 2: GPT-4o-mini SEM Processing Agent
+- Mesma pergunta, 50 iterações cada
+```
+
+### **Teste de Stress**
+```
+Objetivo: Como o sistema se comporta sob carga?
+Configuração:
+- 5 grupos diferentes
+- 100 iterações cada
+- Monitorar tempo de resposta
+```
+
+## 🚨 **Limitações e Considerações**
+
+### **Rate Limits das APIs**
+- **OpenAI**: ~3000 requests/minuto
+- **Anthropic**: ~1000 requests/minuto
+- **Ajuste**: Reduza max_workers se necessário
+
+### **Recursos do Sistema**
+- **RAM**: ~100MB por worker ativo
+- **CPU**: Intensivo durante execução
+- **Rede**: Dependente das APIs LLM
+
+### **Custos**
+- **Validação LLM**: ~$0.001 por teste
+- **Testes massivos**: Pode gerar custos significativos
+- **Recomendação**: Comece com poucos testes
+
+## 🔍 **Troubleshooting**
+
+### **Erro: "Dependência faltando"**
+```bash
+pip install -r testes/requirements.txt
+```
+
+### **Erro: "AgentGraph não configurado"**
+```bash
+# Verifique .env com APIs configuradas
+cp .env.example .env
+# Edite .env com suas chaves
+```
+
+### **Erro: "Porta 5001 em uso"**
+```python
+# Em app_teste.py, altere:
+app.run(port=5002)  # Use porta diferente
+```
+
+### **Performance lenta**
+```python
+# Reduza workers em test_runner.py:
+max_workers = 4  # Ao invés de 8
+```
+
+## 📈 **Próximas Funcionalidades**
+
+- [ ] **Testes agendados**: Execução automática
+- [ ] **Comparação histórica**: Evolução ao longo do tempo
+- [ ] **Alertas**: Notificações de degradação
+- [ ] **API REST**: Integração com CI/CD
+- [ ] **Dashboards avançados**: Gráficos interativos
+
+## 🤝 **Contribuição**
+
+Para melhorias ou bugs:
+1. Documente o problema/sugestão
+2. Teste em ambiente isolado
+3. Mantenha compatibilidade com AgentGraph
+4. Atualize documentação se necessário
+
+---
+
+**🎉 Sistema pronto para uso! Execute `python run_massive_tests.py` da raiz do projeto e comece a testar!**

testes/__init__.py

@@ -0,0 +1 @@
+# Pasta de testes massivos para AgentGraph

testes/app_teste.py

@@ -0,0 +1,494 @@
+#!/usr/bin/env python3
+"""
+Sistema de Testes Massivos para AgentGraph
+Interface HTML isolada para testes de consistência e performance
+"""
+import os
+import sys
+import asyncio
+import logging
+from flask import Flask, render_template, request, jsonify, send_file
+from datetime import datetime
+import json
+
+# Adiciona o diretório pai ao path para importar módulos do AgentGraph
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from testes.test_runner import MassiveTestRunner
+from testes.test_validator import TestValidator
+from testes.report_generator import ReportGenerator
+from utils.config import AVAILABLE_MODELS
+
+# Configuração do Flask
+app = Flask(__name__, 
+           template_folder='templates',
+           static_folder='static')
+
+# Configuração de logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+# Instância global do test runner
+test_runner = None
+current_test_session = None
+
+@app.route('/')
+def index():
+    """Página principal do sistema de testes"""
+    return render_template('index.html', 
+                         available_models=AVAILABLE_MODELS)
+
+@app.route('/api/models')
+def get_models():
+    """Retorna modelos disponíveis"""
+    return jsonify({
+        'success': True,
+        'models': AVAILABLE_MODELS
+    })
+
+@app.route('/api/create_test_session', methods=['POST'])
+def create_test_session():
+    """Cria nova sessão de teste"""
+    global current_test_session
+    
+    try:
+        data = request.json
+        question = data.get('question', '').strip()
+        
+        if not question:
+            return jsonify({
+                'success': False,
+                'error': 'Pergunta é obrigatória'
+            })
+        
+        # Cria nova sessão
+        current_test_session = {
+            'id': datetime.now().strftime('%Y%m%d_%H%M%S'),
+            'question': question,
+            'groups': [],
+            'created_at': datetime.now().isoformat(),
+            'status': 'created'
+        }
+        
+        logging.info(f"Nova sessão de teste criada: {current_test_session['id']}")
+        
+        return jsonify({
+            'success': True,
+            'session_id': current_test_session['id'],
+            'message': 'Sessão de teste criada com sucesso'
+        })
+        
+    except Exception as e:
+        logging.error(f"Erro ao criar sessão de teste: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        })
+
+@app.route('/api/add_test_group', methods=['POST'])
+def add_test_group():
+    """Adiciona grupo de teste à sessão atual"""
+    global current_test_session
+    
+    try:
+        if not current_test_session:
+            return jsonify({
+                'success': False,
+                'error': 'Nenhuma sessão de teste ativa'
+            })
+        
+        data = request.json
+        
+        # Validação dos dados
+        required_fields = ['sql_model', 'iterations']
+        for field in required_fields:
+            if field not in data:
+                return jsonify({
+                    'success': False,
+                    'error': f'Campo obrigatório: {field}'
+                })
+        
+        sql_model = data['sql_model']
+        iterations = int(data['iterations'])
+        processing_enabled = data.get('processing_enabled', False)
+        processing_model = data.get('processing_model', None)
+        
+        # Validações
+        if sql_model not in AVAILABLE_MODELS.values():
+            return jsonify({
+                'success': False,
+                'error': 'Modelo SQL inválido'
+            })
+        
+        if iterations < 1 or iterations > 100:
+            return jsonify({
+                'success': False,
+                'error': 'Número de iterações deve ser entre 1 e 100'
+            })
+        
+        if processing_enabled and processing_model not in AVAILABLE_MODELS.values():
+            return jsonify({
+                'success': False,
+                'error': 'Modelo de processamento inválido'
+            })
+        
+        # Cria grupo
+        group = {
+            'id': len(current_test_session['groups']) + 1,
+            'sql_model': sql_model,
+            'sql_model_name': next(k for k, v in AVAILABLE_MODELS.items() if v == sql_model),
+            'processing_enabled': processing_enabled,
+            'processing_model': processing_model,
+            'processing_model_name': next((k for k, v in AVAILABLE_MODELS.items() if v == processing_model), None) if processing_model else None,
+            'iterations': iterations,
+            'created_at': datetime.now().isoformat()
+        }
+        
+        current_test_session['groups'].append(group)
+        
+        logging.info(f"Grupo adicionado à sessão {current_test_session['id']}: {group}")
+        
+        return jsonify({
+            'success': True,
+            'group': group,
+            'total_groups': len(current_test_session['groups']),
+            'message': 'Grupo adicionado com sucesso'
+        })
+        
+    except Exception as e:
+        logging.error(f"Erro ao adicionar grupo: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        })
+
+@app.route('/api/get_session_info')
+def get_session_info():
+    """Retorna informações da sessão atual"""
+    global current_test_session
+    
+    if not current_test_session:
+        return jsonify({
+            'success': False,
+            'error': 'Nenhuma sessão ativa'
+        })
+    
+    return jsonify({
+        'success': True,
+        'session': current_test_session
+    })
+
+@app.route('/api/run_tests', methods=['POST'])
+def run_tests():
+    """Executa os testes da sessão atual"""
+    global test_runner, current_test_session
+    
+    try:
+        if not current_test_session:
+            return jsonify({
+                'success': False,
+                'error': 'Nenhuma sessão de teste ativa'
+            })
+        
+        if not current_test_session['groups']:
+            return jsonify({
+                'success': False,
+                'error': 'Nenhum grupo de teste configurado'
+            })
+        
+        data = request.json
+        validation_method = data.get('validation_method', 'llm')
+        expected_content = data.get('expected_content', '') if validation_method == 'keyword' else None
+        
+        # Atualiza status
+        current_test_session['status'] = 'running'
+        current_test_session['started_at'] = datetime.now().isoformat()
+        
+        # Cria test runner
+        test_runner = MassiveTestRunner(max_workers=5)  # Paralelismo de 5 workers
+
+        # Executa testes de forma assíncrona
+        def run_async_tests():
+            print(f"\n🚀 INICIANDO EXECUÇÃO DE TESTES - {datetime.now().strftime('%H:%M:%S')}")
+            print(f"📊 Sessão: {current_test_session['id']}")
+            print(f"❓ Pergunta: {current_test_session['question']}")
+            print(f"👥 Grupos: {len(current_test_session['groups'])}")
+            print(f"🔢 Total de testes: {sum(g['iterations'] for g in current_test_session['groups'])}")
+            print("=" * 60)
+
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            try:
+                result = loop.run_until_complete(
+                    test_runner.run_test_session(
+                        current_test_session,
+                        validation_method,
+                        expected_content
+                    )
+                )
+                # Marca como concluído após execução
+                current_test_session['status'] = 'completed'
+                current_test_session['completed_at'] = datetime.now().isoformat()
+
+                print(f"\n🎉 TESTES CONCLUÍDOS COM SUCESSO - {datetime.now().strftime('%H:%M:%S')}")
+                print(f"✅ Sessão: {current_test_session['id']}")
+                print("=" * 60)
+
+                logging.info(f"✅ Testes concluídos com sucesso: {current_test_session['id']}")
+                return result
+            except Exception as e:
+                current_test_session['status'] = 'error'
+                current_test_session['error'] = str(e)
+
+                print(f"\n❌ ERRO NA EXECUÇÃO DOS TESTES - {datetime.now().strftime('%H:%M:%S')}")
+                print(f"💥 Erro: {e}")
+                print("=" * 60)
+
+                logging.error(f"❌ Erro na execução dos testes: {e}")
+                raise
+            finally:
+                loop.close()
+
+        # Inicia execução em thread separada
+        import threading
+        test_thread = threading.Thread(target=run_async_tests)
+        test_thread.daemon = False  # Não daemon para garantir conclusão
+        test_thread.start()
+        
+        return jsonify({
+            'success': True,
+            'message': 'Testes iniciados com sucesso',
+            'session_id': current_test_session['id']
+        })
+        
+    except Exception as e:
+        logging.error(f"Erro ao executar testes: {e}")
+        current_test_session['status'] = 'error'
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        })
+
+@app.route('/api/test_status')
+def get_test_status():
+    """Retorna status atual dos testes"""
+    global test_runner, current_test_session
+
+    if not current_test_session:
+        return jsonify({
+            'success': False,
+            'error': 'Nenhuma sessão ativa'
+        })
+
+    status_info = {
+        'session_id': current_test_session['id'],
+        'status': current_test_session.get('status', 'unknown'),
+        'progress': 0,
+        'current_group': None,
+        'completed_tests': 0,
+        'total_tests': sum(group['iterations'] for group in current_test_session['groups']),
+        'estimated_remaining': None
+    }
+
+    if test_runner:
+        try:
+            runner_status = test_runner.get_status()
+            status_info.update(runner_status)
+
+            # Se o runner indica que terminou, atualiza a sessão
+            if runner_status.get('current_status') == 'completed' and current_test_session.get('status') != 'completed':
+                current_test_session['status'] = 'completed'
+                current_test_session['completed_at'] = datetime.now().isoformat()
+                logging.info(f"🎉 Sessão {current_test_session['id']} marcada como concluída")
+
+        except Exception as e:
+            logging.error(f"Erro ao obter status do runner: {e}")
+            status_info['error'] = str(e)
+
+    # Adiciona informações de testes em execução
+    if test_runner:
+        status_info['running_tests'] = runner_status.get('running_tests_details', [])
+        status_info['running_tests_count'] = runner_status.get('running_tests_count', 0)
+        status_info['current_test'] = runner_status.get('current_test')
+        status_info['cancelled_tests'] = len(runner_status.get('cancelled_tests', []))
+        status_info['timeout_tests'] = len(runner_status.get('timeout_tests', []))
+
+    return jsonify({
+        'success': True,
+        'status': status_info
+    })
+
+@app.route('/api/cancel_test', methods=['POST'])
+def cancel_current_test():
+    """Cancela o teste atual ou específico"""
+    global test_runner
+
+    if not test_runner:
+        return jsonify({
+            'success': False,
+            'error': 'Nenhum teste em execução'
+        })
+
+    try:
+        data = request.get_json() or {}
+        thread_id = data.get('thread_id')  # Opcional - cancela teste específico
+
+        cancelled = test_runner.cancel_current_test(thread_id)
+
+        if cancelled:
+            return jsonify({
+                'success': True,
+                'message': f'Teste {"específico" if thread_id else "atual"} cancelado com sucesso',
+                'cancelled_test': thread_id
+            })
+        else:
+            return jsonify({
+                'success': False,
+                'error': 'Nenhum teste encontrado para cancelar'
+            })
+
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': f'Erro ao cancelar teste: {str(e)}'
+        })
+
+@app.route('/api/cancel_all_tests', methods=['POST'])
+def cancel_all_tests():
+    """Cancela todos os testes em execução"""
+    global test_runner
+
+    if not test_runner:
+        return jsonify({
+            'success': False,
+            'error': 'Nenhum teste em execução'
+        })
+
+    try:
+        cancelled_count = test_runner.cancel_all_tests()
+
+        return jsonify({
+            'success': True,
+            'message': f'{cancelled_count} testes cancelados',
+            'cancelled_count': cancelled_count
+        })
+
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': f'Erro ao cancelar testes: {str(e)}'
+        })
+
+@app.route('/api/skip_stuck_tests', methods=['POST'])
+def skip_stuck_tests():
+    """Marca testes travados para cancelamento"""
+    global test_runner
+
+    if not test_runner:
+        return jsonify({
+            'success': False,
+            'error': 'Nenhum teste em execução'
+        })
+
+    try:
+        data = request.get_json() or {}
+        max_duration = data.get('max_duration', 120)  # 2 minutos padrão
+
+        stuck_count = test_runner.skip_stuck_tests(max_duration)
+
+        return jsonify({
+            'success': True,
+            'message': f'{stuck_count} testes travados marcados para cancelamento',
+            'stuck_count': stuck_count,
+            'max_duration': max_duration
+        })
+
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': f'Erro ao marcar testes travados: {str(e)}'
+        })
+
+@app.route('/api/test_results')
+def get_test_results():
+    """Retorna resultados dos testes"""
+    global test_runner, current_test_session
+
+    if not test_runner:
+        return jsonify({
+            'success': False,
+            'error': 'Nenhum teste executado'
+        })
+
+    if not current_test_session:
+        return jsonify({
+            'success': False,
+            'error': 'Nenhuma sessão ativa'
+        })
+
+    try:
+        results = test_runner.get_results()
+
+        # Verifica se há resultados válidos
+        if not results or not results.get('group_results'):
+            return jsonify({
+                'success': False,
+                'error': 'Resultados ainda não disponíveis'
+            })
+
+        logging.info(f"📊 Enviando resultados: {len(results.get('group_results', []))} grupos, {len(results.get('individual_results', []))} testes individuais")
+
+        return jsonify({
+            'success': True,
+            'results': results
+        })
+    except Exception as e:
+        logging.error(f"Erro ao obter resultados: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        })
+
+@app.route('/api/download_csv')
+def download_csv():
+    """Gera e baixa relatório CSV"""
+    global test_runner
+    
+    if not test_runner:
+        return jsonify({
+            'success': False,
+            'error': 'Nenhum teste executado'
+        })
+    
+    try:
+        # Gera relatório
+        report_generator = ReportGenerator()
+        csv_path = report_generator.generate_csv_report(test_runner.get_results())
+        
+        return send_file(
+            csv_path,
+            as_attachment=True,
+            download_name=f'teste_agentgraph_{datetime.now().strftime("%Y%m%d_%H%M%S")}.csv'
+        )
+    except Exception as e:
+        logging.error(f"Erro ao gerar CSV: {e}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        })
+
+if __name__ == '__main__':
+    print("🧪 Sistema de Testes Massivos - AgentGraph")
+    print("=" * 50)
+    print("🌐 Acesse: http://localhost:5001")
+    print("📊 Interface de testes disponível")
+    print("=" * 50)
+    
+    app.run(
+        host='0.0.0.0',
+        port=5001,
+        debug=True,
+        threaded=True
+    )

testes/report_generator.py

@@ -0,0 +1,335 @@
+#!/usr/bin/env python3
+"""
+Gerador de relatórios para testes massivos
+"""
+import pandas as pd
+import logging
+import os
+from datetime import datetime
+from typing import Dict, Any, List
+import json
+
+class ReportGenerator:
+    """
+    Gerador de relatórios em CSV e outros formatos
+    """
+    
+    def __init__(self, output_dir: str = "testes/reports"):
+        """
+        Inicializa o gerador de relatórios
+        
+        Args:
+            output_dir: Diretório para salvar relatórios
+        """
+        self.output_dir = output_dir
+        self._ensure_output_dir()
+    
+    def _ensure_output_dir(self):
+        """Garante que o diretório de saída existe"""
+        os.makedirs(self.output_dir, exist_ok=True)
+    
+    def generate_csv_report(self, results: Dict[str, Any]) -> str:
+        """
+        Gera relatório completo em CSV/Excel
+
+        Args:
+            results: Resultados dos testes
+
+        Returns:
+            Caminho do arquivo Excel gerado
+        """
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+            # Corrige caminhos para Windows
+            excel_filename = f"relatorio_testes_{timestamp}.xlsx"
+            excel_path = os.path.join(self.output_dir, excel_filename)
+            excel_path = os.path.normpath(excel_path)  # Normaliza barras
+
+            print(f"📊 Gerando relatório Excel: {excel_path}")
+
+            # Cria Excel com múltiplas abas
+            with pd.ExcelWriter(excel_path, engine='openpyxl') as writer:
+
+                # Aba 1: Resumo por Grupo
+                group_summary_df = self._create_group_summary_dataframe(results)
+                if not group_summary_df.empty:
+                    group_summary_df.to_excel(writer, sheet_name='Resumo_Grupos', index=False)
+                    print(f"✅ Aba 'Resumo_Grupos' criada com {len(group_summary_df)} linhas")
+
+                # Aba 2: Resultados Individuais
+                individual_df = self._create_individual_results_dataframe(results)
+                if not individual_df.empty:
+                    individual_df.to_excel(writer, sheet_name='Resultados_Individuais', index=False)
+                    print(f"✅ Aba 'Resultados_Individuais' criada com {len(individual_df)} linhas")
+
+                # Aba 3: Resumo Geral
+                general_summary_df = self._create_general_summary_dataframe(results)
+                if not general_summary_df.empty:
+                    general_summary_df.to_excel(writer, sheet_name='Resumo_Geral', index=False)
+                    print(f"✅ Aba 'Resumo_Geral' criada com {len(general_summary_df)} linhas")
+
+            # Também gera CSVs separados com separador correto
+            csv_dir = os.path.join(self.output_dir, f"csv_{timestamp}")
+            os.makedirs(csv_dir, exist_ok=True)
+
+            if not group_summary_df.empty:
+                csv_grupos = os.path.join(csv_dir, "resumo_grupos.csv")
+                group_summary_df.to_csv(csv_grupos, index=False, encoding='utf-8-sig', sep=';')
+                print(f"✅ CSV grupos: {csv_grupos}")
+
+            if not individual_df.empty:
+                csv_individual = os.path.join(csv_dir, "resultados_individuais.csv")
+                individual_df.to_csv(csv_individual, index=False, encoding='utf-8-sig', sep=';')
+                print(f"✅ CSV individual: {csv_individual}")
+
+            if not general_summary_df.empty:
+                csv_geral = os.path.join(csv_dir, "resumo_geral.csv")
+                general_summary_df.to_csv(csv_geral, index=False, encoding='utf-8-sig', sep=';')
+                print(f"✅ CSV geral: {csv_geral}")
+
+            print(f"🎉 Relatório completo gerado: {excel_path}")
+            logging.info(f"Relatório gerado: {excel_path}")
+            return excel_path
+
+        except Exception as e:
+            print(f"❌ Erro ao gerar relatório: {e}")
+            logging.error(f"Erro ao gerar relatório CSV: {e}")
+            raise
+    
+    def _create_group_summary_dataframe(self, results: Dict[str, Any]) -> pd.DataFrame:
+        """
+        Cria DataFrame com resumo por grupo
+        
+        Args:
+            results: Resultados dos testes
+            
+        Returns:
+            DataFrame com resumo dos grupos
+        """
+        group_results = results.get('group_results', [])
+        
+        if not group_results:
+            return pd.DataFrame()
+        
+        summary_data = []
+        
+        for group in group_results:
+            config = group.get('group_config', {})
+            
+            summary_data.append({
+                'Grupo_ID': group.get('group_id'),
+                'Modelo_SQL': config.get('sql_model_name'),
+                'Processing_Agent_Ativo': 'Sim' if config.get('processing_enabled') else 'Não',
+                'Modelo_Processing': config.get('processing_model_name', 'N/A'),
+                'Total_Testes': group.get('total_tests'),
+                'Testes_Sucessos': group.get('successful_tests'),
+                'Respostas_Válidas': group.get('valid_responses'),
+                'Taxa_Sucesso_%': group.get('success_rate'),
+                'Taxa_Validação_%': group.get('validation_rate'),
+                'Consistência_Resposta_%': group.get('response_consistency'),
+                'Consistência_SQL_%': group.get('sql_consistency'),
+                'Tempo_Médio_Execução_s': group.get('avg_execution_time'),
+                'Erros_Totais': group.get('error_count', 0)
+            })
+        
+        return pd.DataFrame(summary_data)
+    
+    def _create_individual_results_dataframe(self, results: Dict[str, Any]) -> pd.DataFrame:
+        """
+        Cria DataFrame com resultados individuais
+        
+        Args:
+            results: Resultados dos testes
+            
+        Returns:
+            DataFrame com resultados individuais
+        """
+        individual_results = results.get('individual_results', [])
+        
+        if not individual_results:
+            return pd.DataFrame()
+        
+        individual_data = []
+        
+        for result in individual_results:
+            validation = result.get('validation', {})
+            
+            individual_data.append({
+                'Grupo_ID': result.get('group_id'),
+                'Iteração': result.get('iteration'),
+                'Thread_ID': result.get('thread_id'),
+                'Timestamp': result.get('timestamp'),
+                'Modelo_SQL': result.get('sql_model'),
+                'Processing_Agent_Ativo': 'Sim' if result.get('processing_enabled') else 'Não',
+                'Modelo_Processing': result.get('processing_model', 'N/A'),
+                'Pergunta': result.get('question'),
+                'Query_SQL': result.get('sql_query'),
+                'Resposta_Final': result.get('response'),
+                'Sucesso': 'Sim' if result.get('success') else 'Não',
+                'Erro': result.get('error', ''),
+                'Tempo_Execução_s': result.get('execution_time'),
+                'Validação_Válida': 'Sim' if validation.get('valid') else 'Não',
+                'Pontuação_Validação': validation.get('score', 0),
+                'Razão_Validação': validation.get('reason', ''),
+                'Método_Validação': validation.get('method', '')
+            })
+        
+        return pd.DataFrame(individual_data)
+    
+    def _create_general_summary_dataframe(self, results: Dict[str, Any]) -> pd.DataFrame:
+        """
+        Cria DataFrame com resumo geral
+        
+        Args:
+            results: Resultados dos testes
+            
+        Returns:
+            DataFrame com resumo geral
+        """
+        session_info = results.get('session_info', {})
+        summary = results.get('summary', {})
+        
+        general_data = [
+            {'Métrica': 'ID da Sessão', 'Valor': session_info.get('id', '')},
+            {'Métrica': 'Pergunta do Teste', 'Valor': session_info.get('question', '')},
+            {'Métrica': 'Método de Validação', 'Valor': session_info.get('validation_method', '')},
+            {'Métrica': 'Total de Grupos', 'Valor': summary.get('total_groups', 0)},
+            {'Métrica': 'Total de Testes', 'Valor': summary.get('total_tests', 0)},
+            {'Métrica': 'Total de Sucessos', 'Valor': summary.get('total_successful', 0)},
+            {'Métrica': 'Total de Válidos', 'Valor': summary.get('total_valid', 0)},
+            {'Métrica': 'Taxa Geral de Sucesso (%)', 'Valor': summary.get('overall_success_rate', 0)},
+            {'Métrica': 'Taxa Geral de Validação (%)', 'Valor': summary.get('overall_validation_rate', 0)},
+            {'Métrica': 'Consistência Média de Resposta (%)', 'Valor': summary.get('avg_response_consistency', 0)},
+            {'Métrica': 'Consistência Média de SQL (%)', 'Valor': summary.get('avg_sql_consistency', 0)},
+        ]
+        
+        # Adiciona informações do melhor grupo
+        best_group = summary.get('best_performing_group', {})
+        if best_group:
+            config = best_group.get('group_config', {})
+            general_data.extend([
+                {'Métrica': 'Melhor Grupo - ID', 'Valor': best_group.get('group_id', '')},
+                {'Métrica': 'Melhor Grupo - Modelo SQL', 'Valor': config.get('sql_model_name', '')},
+                {'Métrica': 'Melhor Grupo - Processing Agent', 'Valor': 'Sim' if config.get('processing_enabled') else 'Não'},
+                {'Métrica': 'Melhor Grupo - Taxa Validação (%)', 'Valor': best_group.get('validation_rate', 0)},
+            ])
+        
+        # Adiciona informações do grupo mais consistente
+        consistent_group = summary.get('most_consistent_group', {})
+        if consistent_group:
+            config = consistent_group.get('group_config', {})
+            general_data.extend([
+                {'Métrica': 'Grupo Mais Consistente - ID', 'Valor': consistent_group.get('group_id', '')},
+                {'Métrica': 'Grupo Mais Consistente - Modelo SQL', 'Valor': config.get('sql_model_name', '')},
+                {'Métrica': 'Grupo Mais Consistente - Consistência (%)', 'Valor': consistent_group.get('response_consistency', 0)},
+            ])
+        
+        return pd.DataFrame(general_data)
+    
+    def generate_json_report(self, results: Dict[str, Any]) -> str:
+        """
+        Gera relatório em formato JSON
+        
+        Args:
+            results: Resultados dos testes
+            
+        Returns:
+            Caminho do arquivo JSON gerado
+        """
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            json_path = os.path.join(self.output_dir, f"relatorio_testes_{timestamp}.json")
+            
+            with open(json_path, 'w', encoding='utf-8') as f:
+                json.dump(results, f, indent=2, ensure_ascii=False, default=str)
+            
+            logging.info(f"Relatório JSON gerado: {json_path}")
+            return json_path
+            
+        except Exception as e:
+            logging.error(f"Erro ao gerar relatório JSON: {e}")
+            raise
+    
+    def generate_html_summary(self, results: Dict[str, Any]) -> str:
+        """
+        Gera resumo em HTML
+        
+        Args:
+            results: Resultados dos testes
+            
+        Returns:
+            Caminho do arquivo HTML gerado
+        """
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            html_path = os.path.join(self.output_dir, f"resumo_testes_{timestamp}.html")
+            
+            # Cria DataFrames
+            group_df = self._create_group_summary_dataframe(results)
+            general_df = self._create_general_summary_dataframe(results)
+            
+            # Gera HTML
+            html_content = f"""
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Relatório de Testes - AgentGraph</title>
+    <style>
+        body {{ font-family: Arial, sans-serif; margin: 20px; }}
+        table {{ border-collapse: collapse; width: 100%; margin: 20px 0; }}
+        th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
+        th {{ background-color: #f2f2f2; }}
+        .summary {{ background-color: #e7f3ff; padding: 15px; margin: 20px 0; }}
+        .metric {{ margin: 5px 0; }}
+    </style>
+</head>
+<body>
+    <h1>Relatório de Testes Massivos - AgentGraph</h1>
+    <p>Gerado em: {datetime.now().strftime('%d/%m/%Y %H:%M:%S')}</p>
+    
+    <div class="summary">
+        <h2>Resumo Geral</h2>
+        {general_df.to_html(index=False, escape=False)}
+    </div>
+    
+    <h2>Resumo por Grupo</h2>
+    {group_df.to_html(index=False, escape=False)}
+    
+</body>
+</html>
+"""
+            
+            with open(html_path, 'w', encoding='utf-8') as f:
+                f.write(html_content)
+            
+            logging.info(f"Resumo HTML gerado: {html_path}")
+            return html_path
+            
+        except Exception as e:
+            logging.error(f"Erro ao gerar resumo HTML: {e}")
+            raise
+    
+    def generate_all_reports(self, results: Dict[str, Any]) -> Dict[str, str]:
+        """
+        Gera todos os tipos de relatório
+        
+        Args:
+            results: Resultados dos testes
+            
+        Returns:
+            Dicionário com caminhos dos arquivos gerados
+        """
+        report_paths = {}
+        
+        try:
+            report_paths['csv'] = self.generate_csv_report(results)
+            report_paths['json'] = self.generate_json_report(results)
+            report_paths['html'] = self.generate_html_summary(results)
+            
+            logging.info(f"Todos os relatórios gerados: {report_paths}")
+            return report_paths
+            
+        except Exception as e:
+            logging.error(f"Erro ao gerar relatórios: {e}")
+            raise

testes/reports/.gitkeep

@@ -0,0 +1 @@
+# Pasta para armazenar relatórios gerados pelos testes

testes/requirements.txt

@@ -0,0 +1,5 @@
+flask>=2.3.0
+pandas>=1.5.0
+openpyxl>=3.1.0
+asyncio
+concurrent.futures

testes/static/js/app.js

@@ -0,0 +1,748 @@
+// Sistema de Testes Massivos - JavaScript
+class TestManager {
+    constructor() {
+        this.sessionId = null;
+        this.groups = [];
+        this.isRunning = false;
+        this.statusInterval = null;
+        
+        this.initializeEventListeners();
+    }
+    
+    initializeEventListeners() {
+        // Criar sessão
+        document.getElementById('createSession').addEventListener('click', () => {
+            this.createSession();
+        });
+        
+        // Toggle Processing Agent
+        document.getElementById('enableProcessing').addEventListener('change', (e) => {
+            const processingDiv = document.getElementById('processingModelDiv');
+            processingDiv.style.display = e.target.checked ? 'block' : 'none';
+        });
+        
+        // Toggle método de validação
+        document.getElementById('validationMethod').addEventListener('change', (e) => {
+            const keywordDiv = document.getElementById('keywordDiv');
+            keywordDiv.style.display = e.target.value === 'keyword' ? 'block' : 'none';
+        });
+        
+        // Adicionar grupo
+        document.getElementById('addGroup').addEventListener('click', () => {
+            this.addGroup();
+        });
+        
+        // Executar testes
+        document.getElementById('runTests').addEventListener('click', () => {
+            this.runTests();
+        });
+        
+        // Download CSV
+        document.getElementById('downloadCsv').addEventListener('click', () => {
+            this.downloadCsv();
+        });
+    }
+    
+    async createSession() {
+        const question = document.getElementById('testQuestion').value.trim();
+        
+        if (!question) {
+            this.showAlert('Por favor, digite uma pergunta para o teste.', 'warning');
+            return;
+        }
+        
+        try {
+            const response = await fetch('/api/create_test_session', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ question })
+            });
+            
+            const data = await response.json();
+            
+            if (data.success) {
+                this.sessionId = data.session_id;
+                this.showSessionInfo(question);
+                this.showAlert('Sessão criada com sucesso!', 'success');
+                
+                // Mostra configuração de grupo
+                document.getElementById('groupConfig').style.display = 'block';
+                document.getElementById('validationConfig').style.display = 'block';
+                
+                // Desabilita criação de nova sessão
+                document.getElementById('createSession').disabled = true;
+                document.getElementById('testQuestion').disabled = true;
+                
+            } else {
+                this.showAlert(data.error, 'danger');
+            }
+        } catch (error) {
+            this.showAlert('Erro ao criar sessão: ' + error.message, 'danger');
+        }
+    }
+    
+    showSessionInfo(question) {
+        const sessionInfo = document.getElementById('sessionInfo');
+        const sessionDetails = document.getElementById('sessionDetails');
+        
+        sessionDetails.innerHTML = `
+            <strong>ID:</strong> ${this.sessionId}<br>
+            <strong>Pergunta:</strong> ${question}<br>
+            <strong>Criado em:</strong> ${new Date().toLocaleString()}
+        `;
+        
+        sessionInfo.style.display = 'block';
+    }
+    
+    async addGroup() {
+        const sqlModel = document.getElementById('sqlModel').value;
+        const processingEnabled = document.getElementById('enableProcessing').checked;
+        const processingModel = processingEnabled ? document.getElementById('processingModel').value : null;
+        const iterations = parseInt(document.getElementById('iterations').value);
+        
+        if (iterations < 1 || iterations > 100) {
+            this.showAlert('Número de iterações deve ser entre 1 e 100.', 'warning');
+            return;
+        }
+        
+        try {
+            const response = await fetch('/api/add_test_group', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    sql_model: sqlModel,
+                    processing_enabled: processingEnabled,
+                    processing_model: processingModel,
+                    iterations: iterations
+                })
+            });
+            
+            const data = await response.json();
+            
+            if (data.success) {
+                this.groups.push(data.group);
+                this.updateGroupsList();
+                this.showAlert(`Grupo ${data.group.id} adicionado com sucesso!`, 'success');
+                
+                // Reset form
+                document.getElementById('iterations').value = 5;
+                document.getElementById('enableProcessing').checked = false;
+                document.getElementById('processingModelDiv').style.display = 'none';
+                
+            } else {
+                this.showAlert(data.error, 'danger');
+            }
+        } catch (error) {
+            this.showAlert('Erro ao adicionar grupo: ' + error.message, 'danger');
+        }
+    }
+    
+    updateGroupsList() {
+        const groupsList = document.getElementById('groupsList');
+        
+        if (this.groups.length === 0) {
+            groupsList.innerHTML = '<p class="text-muted">Nenhum grupo configurado ainda.</p>';
+            return;
+        }
+        
+        let html = '';
+        this.groups.forEach(group => {
+            html += `
+                <div class="test-group-card">
+                    <div class="d-flex justify-content-between align-items-center">
+                        <div>
+                            <h6><i class="fas fa-cog"></i> Grupo ${group.id}</h6>
+                            <small class="text-muted">
+                                <strong>SQL:</strong> ${group.sql_model_name}<br>
+                                <strong>Processing:</strong> ${group.processing_enabled ? group.processing_model_name : 'Desativado'}<br>
+                                <strong>Iterações:</strong> ${group.iterations}
+                            </small>
+                        </div>
+                        <div class="text-end">
+                            <span class="badge bg-primary">${group.iterations} testes</span>
+                        </div>
+                    </div>
+                </div>
+            `;
+        });
+        
+        groupsList.innerHTML = html;
+    }
+    
+    async runTests() {
+        if (this.groups.length === 0) {
+            this.showAlert('Adicione pelo menos um grupo de teste.', 'warning');
+            return;
+        }
+        
+        const validationMethod = document.getElementById('validationMethod').value;
+        const expectedContent = document.getElementById('expectedContent').value;
+        
+        if (validationMethod === 'keyword' && !expectedContent.trim()) {
+            this.showAlert('Digite o conteúdo esperado para validação por palavra-chave.', 'warning');
+            return;
+        }
+        
+        try {
+            const response = await fetch('/api/run_tests', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    validation_method: validationMethod,
+                    expected_content: expectedContent
+                })
+            });
+            
+            const data = await response.json();
+            
+            if (data.success) {
+                this.isRunning = true;
+                this.updateStatus('running');
+                this.showProgressContainer();
+                this.startStatusPolling();
+                this.showAlert('Testes iniciados com sucesso!', 'success');
+                
+                // Desabilita controles
+                document.getElementById('addGroup').disabled = true;
+                document.getElementById('runTests').disabled = true;
+                
+            } else {
+                this.showAlert(data.error, 'danger');
+            }
+        } catch (error) {
+            this.showAlert('Erro ao executar testes: ' + error.message, 'danger');
+        }
+    }
+    
+    showProgressContainer() {
+        document.getElementById('progressContainer').style.display = 'block';
+    }
+    
+    startStatusPolling() {
+        this.statusInterval = setInterval(() => {
+            this.checkTestStatus();
+        }, 2000); // Verifica a cada 2 segundos
+    }
+    
+    async checkTestStatus() {
+        try {
+            const response = await fetch('/api/test_status');
+            const data = await response.json();
+
+            if (data.success) {
+                const status = data.status;
+
+                // Atualiza progresso
+                this.updateProgress(status);
+
+                // Log para debug
+                console.log('Status atual:', status.status, 'Progresso:', status.progress);
+
+                // Verifica se terminou
+                if (status.status === 'completed') {
+                    this.isRunning = false;
+                    this.updateStatus('completed');
+                    clearInterval(this.statusInterval);
+                    this.statusInterval = null;
+
+                    console.log('✅ Testes concluídos, carregando resultados...');
+                    await this.loadResults();
+                    this.showAlert('Testes concluídos com sucesso!', 'success');
+
+                    // Reabilita controles
+                    document.getElementById('addGroup').disabled = false;
+                    document.getElementById('runTests').disabled = false;
+
+                } else if (status.status === 'error') {
+                    this.isRunning = false;
+                    this.updateStatus('error');
+                    clearInterval(this.statusInterval);
+                    this.statusInterval = null;
+                    this.showAlert('Erro durante execução dos testes.', 'danger');
+
+                    // Reabilita controles
+                    document.getElementById('addGroup').disabled = false;
+                    document.getElementById('runTests').disabled = false;
+                }
+            } else {
+                console.error('Erro na resposta do status:', data.error);
+            }
+        } catch (error) {
+            console.error('Erro ao verificar status:', error);
+            // Para o polling em caso de erro persistente
+            if (this.statusInterval) {
+                clearInterval(this.statusInterval);
+                this.statusInterval = null;
+                this.showAlert('Erro de comunicação com o servidor.', 'danger');
+            }
+        }
+    }
+    
+    updateProgress(status) {
+        const progressBar = document.getElementById('progressBar');
+        const completedTests = document.getElementById('completedTests');
+        const totalTests = document.getElementById('totalTests');
+        const currentGroup = document.getElementById('currentGroup');
+        const estimatedTime = document.getElementById('estimatedTime');
+
+        progressBar.style.width = status.progress + '%';
+        progressBar.textContent = Math.round(status.progress) + '%';
+
+        completedTests.textContent = status.completed_tests;
+        totalTests.textContent = status.total_tests;
+        currentGroup.textContent = status.current_group || '-';
+
+        if (status.estimated_remaining) {
+            const minutes = Math.floor(status.estimated_remaining / 60);
+            const seconds = Math.floor(status.estimated_remaining % 60);
+            estimatedTime.textContent = `${minutes}m ${seconds}s`;
+        } else {
+            estimatedTime.textContent = '-';
+        }
+
+        // Atualiza informações de testes em execução
+        this.updateRunningTests(status);
+    }
+
+    updateRunningTests(status) {
+        const currentTestDetails = document.getElementById('currentTestDetails');
+        const runningTestsCount = document.getElementById('runningTestsCount');
+        const runningTestsList = document.getElementById('runningTestsList');
+        const runningTestsContainer = document.getElementById('runningTestsContainer');
+
+        // Atualiza contador
+        const runningCount = status.running_tests_count || 0;
+        runningTestsCount.textContent = runningCount;
+        runningTestsCount.className = runningCount > 0 ? 'badge bg-primary' : 'badge bg-secondary';
+
+        // Atualiza teste atual
+        if (status.current_test) {
+            currentTestDetails.innerHTML = `
+                <span class="badge bg-info">${status.current_test}</span>
+                <small class="text-muted d-block">Teste em execução</small>
+            `;
+        } else {
+            currentTestDetails.innerHTML = '<span class="text-muted">Nenhum teste em execução</span>';
+        }
+
+        // Atualiza lista de testes em execução
+        if (runningCount > 0 && status.running_tests) {
+            runningTestsList.style.display = 'block';
+            runningTestsContainer.innerHTML = '';
+
+            status.running_tests.forEach(test => {
+                const duration = Math.floor((Date.now() / 1000) - test.start_time);
+                const minutes = Math.floor(duration / 60);
+                const seconds = duration % 60;
+
+                const testElement = document.createElement('div');
+                testElement.className = 'list-group-item d-flex justify-content-between align-items-center';
+                testElement.innerHTML = `
+                    <div>
+                        <strong>Grupo ${test.group_id}</strong> - Iteração ${test.iteration}
+                        <br><small class="text-muted">${test.question}</small>
+                    </div>
+                    <div class="text-end">
+                        <span class="badge bg-warning">${minutes}m ${seconds}s</span>
+                        <button class="btn btn-sm btn-outline-danger ms-2" onclick="testManager.cancelSpecificTest('${test.thread_id}')">
+                            <i class="fas fa-times"></i>
+                        </button>
+                    </div>
+                `;
+                runningTestsContainer.appendChild(testElement);
+            });
+        } else {
+            runningTestsList.style.display = 'none';
+        }
+
+        // Habilita/desabilita botões
+        const hasRunningTests = runningCount > 0;
+        document.getElementById('cancelCurrentBtn').disabled = !hasRunningTests;
+        document.getElementById('cancelAllBtn').disabled = !hasRunningTests;
+        document.getElementById('skipStuckBtn').disabled = !hasRunningTests;
+    }
+
+    async cancelCurrentTest() {
+        try {
+            const response = await fetch('/api/cancel_test', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            const data = await response.json();
+
+            if (data.success) {
+                this.showAlert(data.message, 'success');
+            } else {
+                this.showAlert(data.error, 'danger');
+            }
+        } catch (error) {
+            this.showAlert('Erro ao cancelar teste: ' + error.message, 'danger');
+        }
+    }
+
+    async cancelSpecificTest(threadId) {
+        try {
+            const response = await fetch('/api/cancel_test', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ thread_id: threadId })
+            });
+
+            const data = await response.json();
+
+            if (data.success) {
+                this.showAlert(data.message, 'success');
+            } else {
+                this.showAlert(data.error, 'danger');
+            }
+        } catch (error) {
+            this.showAlert('Erro ao cancelar teste específico: ' + error.message, 'danger');
+        }
+    }
+
+    async cancelAllTests() {
+        if (!confirm('Tem certeza que deseja cancelar TODOS os testes em execução?')) {
+            return;
+        }
+
+        try {
+            const response = await fetch('/api/cancel_all_tests', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+
+            const data = await response.json();
+
+            if (data.success) {
+                this.showAlert(data.message, 'warning');
+            } else {
+                this.showAlert(data.error, 'danger');
+            }
+        } catch (error) {
+            this.showAlert('Erro ao cancelar todos os testes: ' + error.message, 'danger');
+        }
+    }
+
+    async skipStuckTests() {
+        try {
+            const response = await fetch('/api/skip_stuck_tests', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ max_duration: 120 })
+            });
+
+            const data = await response.json();
+
+            if (data.success) {
+                this.showAlert(data.message, 'info');
+            } else {
+                this.showAlert(data.error, 'danger');
+            }
+        } catch (error) {
+            this.showAlert('Erro ao pular testes travados: ' + error.message, 'danger');
+        }
+    }
+    
+    async loadResults() {
+        try {
+            console.log('🔄 Carregando resultados...');
+            const response = await fetch('/api/test_results');
+            const data = await response.json();
+
+            console.log('📊 Resposta dos resultados:', data);
+
+            if (data.success) {
+                console.log('✅ Resultados carregados, exibindo...');
+                this.displayResults(data.results);
+                document.getElementById('resultsContainer').style.display = 'block';
+                console.log('✅ Interface de resultados exibida');
+            } else {
+                console.error('❌ Erro nos resultados:', data.error);
+                this.showAlert('Erro ao carregar resultados: ' + data.error, 'danger');
+            }
+        } catch (error) {
+            console.error('❌ Erro ao carregar resultados:', error);
+            this.showAlert('Erro ao carregar resultados: ' + error.message, 'danger');
+        }
+    }
+    
+    displayResults(results) {
+        this.displaySummary(results.summary);
+        this.displayGroupResults(results.group_results);
+        this.displayIndividualResults(results.individual_results);
+    }
+    
+    displaySummary(summary) {
+        const summaryContent = document.getElementById('summaryContent');
+        
+        summaryContent.innerHTML = `
+            <div class="row">
+                <div class="col-md-3">
+                    <div class="metric-card">
+                        <div class="metric-value">${summary.total_tests}</div>
+                        <div class="metric-label">Total de Testes</div>
+                    </div>
+                </div>
+                <div class="col-md-3">
+                    <div class="metric-card">
+                        <div class="metric-value">${summary.overall_success_rate}%</div>
+                        <div class="metric-label">Taxa de Sucesso</div>
+                    </div>
+                </div>
+                <div class="col-md-3">
+                    <div class="metric-card">
+                        <div class="metric-value">${summary.overall_validation_rate}%</div>
+                        <div class="metric-label">Taxa de Validação</div>
+                    </div>
+                </div>
+                <div class="col-md-3">
+                    <div class="metric-card">
+                        <div class="metric-value">${summary.avg_response_consistency}%</div>
+                        <div class="metric-label">Consistência Média</div>
+                    </div>
+                </div>
+            </div>
+            
+            <div class="row mt-4">
+                <div class="col-md-6">
+                    <h6>🏆 Melhor Grupo (Validação)</h6>
+                    <div class="card">
+                        <div class="card-body">
+                            <strong>Grupo ${summary.best_performing_group.group_id}</strong><br>
+                            <small>
+                                ${summary.best_performing_group.group_config.sql_model_name}<br>
+                                Processing: ${summary.best_performing_group.group_config.processing_enabled ? 'Ativo' : 'Inativo'}<br>
+                                Taxa: ${summary.best_performing_group.validation_rate}%
+                            </small>
+                        </div>
+                    </div>
+                </div>
+                <div class="col-md-6">
+                    <h6>🎯 Grupo Mais Consistente</h6>
+                    <div class="card">
+                        <div class="card-body">
+                            <strong>Grupo ${summary.most_consistent_group.group_id}</strong><br>
+                            <small>
+                                ${summary.most_consistent_group.group_config.sql_model_name}<br>
+                                Processing: ${summary.most_consistent_group.group_config.processing_enabled ? 'Ativo' : 'Inativo'}<br>
+                                Consistência: ${summary.most_consistent_group.response_consistency}%
+                            </small>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        `;
+    }
+    
+    displayGroupResults(groupResults) {
+        const groupsContent = document.getElementById('groupsContent');
+        
+        let html = '<div class="table-responsive"><table class="table table-striped"><thead><tr>';
+        html += '<th>Grupo</th><th>Modelo SQL</th><th>Processing</th><th>Testes</th>';
+        html += '<th>Sucesso</th><th>Validação</th><th>Consistência</th><th>Tempo Médio</th>';
+        html += '</tr></thead><tbody>';
+        
+        groupResults.forEach(group => {
+            const config = group.group_config;
+            html += `
+                <tr>
+                    <td><strong>${group.group_id}</strong></td>
+                    <td>${config.sql_model_name}</td>
+                    <td>${config.processing_enabled ? config.processing_model_name : 'Não'}</td>
+                    <td>${group.total_tests}</td>
+                    <td><span class="badge bg-${group.success_rate >= 80 ? 'success' : group.success_rate >= 60 ? 'warning' : 'danger'}">${group.success_rate}%</span></td>
+                    <td><span class="badge bg-${group.validation_rate >= 80 ? 'success' : group.validation_rate >= 60 ? 'warning' : 'danger'}">${group.validation_rate}%</span></td>
+                    <td>${group.response_consistency}%</td>
+                    <td>${group.avg_execution_time}s</td>
+                </tr>
+            `;
+        });
+        
+        html += '</tbody></table></div>';
+        groupsContent.innerHTML = html;
+    }
+    
+    displayIndividualResults(individualResults) {
+        const individualContent = document.getElementById('individualContent');
+        
+        let html = '<div class="table-responsive"><table class="table table-sm"><thead><tr>';
+        html += '<th>Grupo</th><th>Iter.</th><th>Modelo</th><th>Sucesso</th><th>Validação</th><th>Tempo</th><th>Ações</th>';
+        html += '</tr></thead><tbody>';
+        
+        individualResults.slice(0, 100).forEach((result, index) => { // Limita a 100 para performance
+            const validation = result.validation || {};
+            html += `
+                <tr>
+                    <td>${result.group_id}</td>
+                    <td>${result.iteration}</td>
+                    <td><small>${result.sql_model}</small></td>
+                    <td><span class="badge bg-${result.success ? 'success' : 'danger'}">${result.success ? 'Sim' : 'Não'}</span></td>
+                    <td><span class="badge bg-${validation.valid ? 'success' : 'danger'}">${validation.score || 0}</span></td>
+                    <td>${result.execution_time}s</td>
+                    <td><button class="btn btn-sm btn-outline-info" onclick="testManager.showResultDetails(${index})">Ver</button></td>
+                </tr>
+            `;
+        });
+        
+        html += '</tbody></table></div>';
+        
+        if (individualResults.length > 100) {
+            html += `<p class="text-muted mt-2">Mostrando primeiros 100 de ${individualResults.length} resultados. Baixe o CSV para ver todos.</p>`;
+        }
+        
+        individualContent.innerHTML = html;
+        
+        // Armazena resultados para detalhes
+        this.individualResults = individualResults;
+    }
+    
+    showResultDetails(index) {
+        const result = this.individualResults[index];
+        const validation = result.validation || {};
+        
+        const modal = `
+            <div class="modal fade" id="resultModal" tabindex="-1">
+                <div class="modal-dialog modal-lg">
+                    <div class="modal-content">
+                        <div class="modal-header">
+                            <h5 class="modal-title">Detalhes do Teste - Grupo ${result.group_id}, Iteração ${result.iteration}</h5>
+                            <button type="button" class="btn-close" data-bs-dismiss="modal"></button>
+                        </div>
+                        <div class="modal-body">
+                            <h6>Configuração</h6>
+                            <p><strong>Modelo SQL:</strong> ${result.sql_model}<br>
+                            <strong>Processing Agent:</strong> ${result.processing_enabled ? result.processing_model : 'Desativado'}<br>
+                            <strong>Tempo de Execução:</strong> ${result.execution_time}s</p>
+                            
+                            <h6>Query SQL</h6>
+                            <pre class="bg-light p-2"><code>${result.sql_query || 'N/A'}</code></pre>
+                            
+                            <h6>Resposta</h6>
+                            <div class="bg-light p-2" style="max-height: 200px; overflow-y: auto;">
+                                ${result.response || 'N/A'}
+                            </div>
+                            
+                            <h6>Validação</h6>
+                            <p><strong>Válida:</strong> ${validation.valid ? 'Sim' : 'Não'}<br>
+                            <strong>Pontuação:</strong> ${validation.score || 0}<br>
+                            <strong>Razão:</strong> ${validation.reason || 'N/A'}</p>
+                            
+                            ${result.error ? `<h6>Erro</h6><div class="alert alert-danger">${result.error}</div>` : ''}
+                        </div>
+                    </div>
+                </div>
+            </div>
+        `;
+        
+        // Remove modal anterior se existir
+        const existingModal = document.getElementById('resultModal');
+        if (existingModal) {
+            existingModal.remove();
+        }
+        
+        // Adiciona novo modal
+        document.body.insertAdjacentHTML('beforeend', modal);
+        
+        // Mostra modal
+        const modalElement = new bootstrap.Modal(document.getElementById('resultModal'));
+        modalElement.show();
+    }
+    
+    async downloadCsv() {
+        try {
+            const response = await fetch('/api/download_csv');
+            
+            if (response.ok) {
+                const blob = await response.blob();
+                const url = window.URL.createObjectURL(blob);
+                const a = document.createElement('a');
+                a.href = url;
+                a.download = `teste_agentgraph_${new Date().toISOString().slice(0, 19).replace(/:/g, '-')}.xlsx`;
+                document.body.appendChild(a);
+                a.click();
+                window.URL.revokeObjectURL(url);
+                document.body.removeChild(a);
+                
+                this.showAlert('Relatório baixado com sucesso!', 'success');
+            } else {
+                this.showAlert('Erro ao baixar relatório.', 'danger');
+            }
+        } catch (error) {
+            this.showAlert('Erro ao baixar relatório: ' + error.message, 'danger');
+        }
+    }
+    
+    updateStatus(status) {
+        const statusElement = document.getElementById('sessionStatus');
+        statusElement.className = `status-badge status-${status}`;
+        
+        const statusText = {
+            'idle': 'Aguardando',
+            'running': 'Executando',
+            'completed': 'Concluído',
+            'error': 'Erro'
+        };
+        
+        const statusIcon = {
+            'idle': 'circle',
+            'running': 'spinner fa-spin',
+            'completed': 'check-circle',
+            'error': 'exclamation-circle'
+        };
+        
+        statusElement.innerHTML = `<i class="fas fa-${statusIcon[status]}"></i> ${statusText[status]}`;
+    }
+    
+    showAlert(message, type) {
+        // Remove alertas anteriores
+        const existingAlerts = document.querySelectorAll('.alert-dismissible');
+        existingAlerts.forEach(alert => alert.remove());
+        
+        const alert = document.createElement('div');
+        alert.className = `alert alert-${type} alert-dismissible fade show`;
+        alert.innerHTML = `
+            ${message}
+            <button type="button" class="btn-close" data-bs-dismiss="alert"></button>
+        `;
+        
+        document.querySelector('.container-fluid').insertBefore(alert, document.querySelector('.row'));
+        
+        // Remove automaticamente após 5 segundos
+        setTimeout(() => {
+            if (alert.parentNode) {
+                alert.remove();
+            }
+        }, 5000);
+    }
+}
+
+// Inicializa o sistema
+const testManager = new TestManager();
+
+// Funções globais para os botões HTML
+function cancelCurrentTest() {
+    testManager.cancelCurrentTest();
+}
+
+function cancelAllTests() {
+    testManager.cancelAllTests();
+}
+
+function skipStuckTests() {
+    testManager.skipStuckTests();
+}

testes/templates/index.html

@@ -0,0 +1,578 @@
+<!DOCTYPE html>
+<html lang="pt-BR">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sistema de Testes Massivos - AgentGraph</title>
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/css/bootstrap.min.css" rel="stylesheet">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet">
+    <style>
+        /* Design System - Cores Profissionais */
+        :root {
+            --primary-color: #2563eb;
+            --primary-dark: #1d4ed8;
+            --secondary-color: #64748b;
+            --success-color: #059669;
+            --warning-color: #d97706;
+            --danger-color: #dc2626;
+            --info-color: #0891b2;
+
+            --bg-primary: #f8fafc;
+            --bg-secondary: #f1f5f9;
+            --bg-dark: #0f172a;
+            --bg-card: #ffffff;
+
+            --text-primary: #1e293b;
+            --text-secondary: #64748b;
+            --text-muted: #94a3b8;
+
+            --border-color: #e2e8f0;
+            --border-radius: 12px;
+            --shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
+            --shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1);
+            --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1);
+        }
+
+        /* Layout Principal */
+        body {
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+        }
+
+        .container-fluid {
+            padding: 0;
+        }
+
+        /* Sidebar Profissional */
+        .sidebar {
+            background: linear-gradient(135deg, var(--bg-dark), #1e293b);
+            min-height: 100vh;
+            border-right: 1px solid var(--border-color);
+            box-shadow: var(--shadow-lg);
+            padding: 2rem 1.5rem;
+        }
+
+        .sidebar h4 {
+            color: white;
+            font-weight: 800;
+            margin-bottom: 2rem;
+            font-size: 1.5rem;
+        }
+
+        .sidebar h6 {
+            color: #cbd5e1;
+            font-weight: 600;
+            margin-bottom: 1rem;
+            margin-top: 2rem;
+            font-size: 0.875rem;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+
+        .sidebar .form-control,
+        .sidebar .form-select {
+            background: rgba(255, 255, 255, 0.1);
+            border: 1px solid rgba(255, 255, 255, 0.2);
+            color: white;
+            border-radius: 8px;
+        }
+
+        .sidebar .form-control::placeholder {
+            color: rgba(255, 255, 255, 0.6);
+        }
+
+        .sidebar .form-control:focus,
+        .sidebar .form-select:focus {
+            background: rgba(255, 255, 255, 0.15);
+            border-color: var(--primary-color);
+            box-shadow: 0 0 0 3px rgb(37 99 235 / 0.2);
+            color: white;
+        }
+
+        /* Main Content */
+        .main-content {
+            background: var(--bg-primary);
+            min-height: 100vh;
+            padding: 2rem;
+        }
+
+        /* Header Dashboard */
+        .dashboard-header {
+            background: var(--bg-card);
+            border-radius: var(--border-radius);
+            padding: 2rem;
+            margin-bottom: 2rem;
+            border: 1px solid var(--border-color);
+            box-shadow: var(--shadow-sm);
+        }
+
+        .dashboard-header h2 {
+            color: var(--text-primary);
+            font-weight: 800;
+            margin: 0;
+            font-size: 2rem;
+        }
+
+        /* Cards e Componentes */
+        .metric-card {
+            background: linear-gradient(135deg, var(--primary-color), var(--info-color));
+            color: white;
+            border-radius: var(--border-radius);
+            padding: 2rem;
+            margin: 1rem 0;
+            box-shadow: var(--shadow-md);
+            transition: all 0.3s ease;
+            border: none;
+        }
+
+        .metric-card:hover {
+            transform: translateY(-2px);
+            box-shadow: var(--shadow-lg);
+        }
+
+        .metric-value {
+            font-size: 3rem;
+            font-weight: 800;
+            line-height: 1;
+            margin-bottom: 0.5rem;
+        }
+
+        .metric-label {
+            font-size: 0.875rem;
+            font-weight: 600;
+            opacity: 0.9;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+
+        .test-group-card {
+            background: var(--bg-card);
+            border: 1px solid var(--border-color);
+            border-radius: var(--border-radius);
+            padding: 2rem;
+            margin: 1.5rem 0;
+            box-shadow: var(--shadow-sm);
+            transition: all 0.3s ease;
+        }
+
+        .test-group-card:hover {
+            box-shadow: var(--shadow-md);
+            border-color: var(--primary-color);
+            transform: translateY(-1px);
+        }
+
+        /* Status Badges Modernos */
+        .status-badge {
+            padding: 0.75rem 1.5rem;
+            border-radius: 50px;
+            font-weight: 700;
+            font-size: 0.875rem;
+            display: inline-flex;
+            align-items: center;
+            gap: 0.5rem;
+            box-shadow: var(--shadow-sm);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+
+        .status-idle {
+            background: var(--secondary-color);
+            color: white;
+        }
+        .status-running {
+            background: var(--success-color);
+            color: white;
+            animation: pulse 2s infinite;
+        }
+        .status-completed {
+            background: var(--primary-color);
+            color: white;
+        }
+        .status-error {
+            background: var(--danger-color);
+            color: white;
+        }
+
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.8; }
+        }
+
+        /* Containers */
+        .progress-container {
+            display: none;
+            margin: 2rem 0;
+            background: var(--bg-card);
+            border-radius: var(--border-radius);
+            padding: 2rem;
+            border: 1px solid var(--border-color);
+            box-shadow: var(--shadow-md);
+        }
+
+        .results-container {
+            display: none;
+            margin: 2rem 0;
+        }
+
+        /* Botões Profissionais */
+        .btn {
+            border-radius: 10px;
+            font-weight: 600;
+            padding: 0.875rem 2rem;
+            border: none;
+            transition: all 0.3s ease;
+            box-shadow: var(--shadow-sm);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            font-size: 0.875rem;
+        }
+
+        .btn:hover {
+            transform: translateY(-2px);
+            box-shadow: var(--shadow-md);
+        }
+
+        .btn-primary {
+            background: linear-gradient(135deg, var(--primary-color), var(--primary-dark));
+            border: none;
+        }
+
+        .btn-success {
+            background: linear-gradient(135deg, var(--success-color), #047857);
+        }
+
+        .btn-warning {
+            background: linear-gradient(135deg, var(--warning-color), #b45309);
+        }
+
+        .btn-danger {
+            background: linear-gradient(135deg, var(--danger-color), #b91c1c);
+        }
+
+        /* Progress Bar Moderno */
+        .progress {
+            height: 16px;
+            border-radius: 8px;
+            background: var(--bg-secondary);
+            overflow: hidden;
+            box-shadow: inset 0 1px 2px rgba(0,0,0,0.1);
+        }
+
+        .progress-bar {
+            background: linear-gradient(90deg, var(--primary-color), var(--info-color));
+            border-radius: 8px;
+            transition: width 0.6s ease;
+            position: relative;
+            overflow: hidden;
+        }
+
+        .progress-bar::after {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background: linear-gradient(45deg, transparent 35%, rgba(255,255,255,0.2) 50%, transparent 65%);
+            animation: shimmer 2s infinite;
+        }
+
+        @keyframes shimmer {
+            0% { transform: translateX(-100%); }
+            100% { transform: translateX(100%); }
+        }
+
+        /* Alertas */
+        .alert {
+            border-radius: var(--border-radius);
+            border: none;
+            box-shadow: var(--shadow-sm);
+            padding: 1.5rem;
+        }
+
+        /* Formulários */
+        .form-control, .form-select {
+            border-radius: 10px;
+            border: 2px solid var(--border-color);
+            padding: 0.875rem 1rem;
+            transition: all 0.3s ease;
+            font-weight: 500;
+        }
+
+        .form-control:focus, .form-select:focus {
+            border-color: var(--primary-color);
+            box-shadow: 0 0 0 4px rgb(37 99 235 / 0.1);
+            transform: translateY(-1px);
+        }
+
+        /* Badges */
+        .badge {
+            font-weight: 700;
+            padding: 0.5rem 1rem;
+            border-radius: 8px;
+            font-size: 0.75rem;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+
+        /* Ícones */
+        .fas, .far {
+            margin-right: 0.5rem;
+        }
+
+        /* Responsividade */
+        @media (max-width: 768px) {
+            .main-content {
+                padding: 1rem;
+            }
+
+            .metric-value {
+                font-size: 2rem;
+            }
+
+            .sidebar {
+                padding: 1rem;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container-fluid">
+        <div class="row">
+            <!-- Sidebar -->
+            <div class="col-md-3 sidebar">
+                <h4><i class="fas fa-flask"></i> Sistema de Testes</h4>
+                
+                <!-- Configuração da Pergunta -->
+                <div class="mb-4">
+                    <h6><i class="fas fa-question-circle"></i> Pergunta do Teste</h6>
+                    <textarea id="testQuestion" class="form-control" rows="3" 
+                              placeholder="Digite a pergunta que será testada..."></textarea>
+                    <button id="createSession" class="btn btn-primary btn-sm mt-2 w-100">
+                        <i class="fas fa-plus"></i> Criar Sessão
+                    </button>
+                </div>
+
+                <!-- Configuração de Grupo -->
+                <div id="groupConfig" style="display: none;">
+                    <h6><i class="fas fa-cogs"></i> Configurar Grupo</h6>
+                    
+                    <div class="mb-3">
+                        <label class="form-label">Modelo SQL Agent</label>
+                        <select id="sqlModel" class="form-select form-select-sm">
+                            {% for name, value in available_models.items() %}
+                            <option value="{{ value }}">{{ name }}</option>
+                            {% endfor %}
+                        </select>
+                    </div>
+
+                    <div class="mb-3">
+                        <div class="form-check">
+                            <input class="form-check-input" type="checkbox" id="enableProcessing">
+                            <label class="form-check-label" for="enableProcessing">
+                                Ativar Processing Agent
+                            </label>
+                        </div>
+                    </div>
+
+                    <div id="processingModelDiv" class="mb-3" style="display: none;">
+                        <label class="form-label">Modelo Processing Agent</label>
+                        <select id="processingModel" class="form-select form-select-sm">
+                            {% for name, value in available_models.items() %}
+                            <option value="{{ value }}">{{ name }}</option>
+                            {% endfor %}
+                        </select>
+                    </div>
+
+                    <div class="mb-3">
+                        <label class="form-label">Número de Iterações</label>
+                        <input type="number" id="iterations" class="form-control form-control-sm" 
+                               value="5" min="1" max="100">
+                    </div>
+
+                    <button id="addGroup" class="btn btn-success btn-sm w-100 mb-2">
+                        <i class="fas fa-plus"></i> Adicionar Grupo
+                    </button>
+                </div>
+
+                <!-- Validação -->
+                <div id="validationConfig" style="display: none;">
+                    <hr>
+                    <h6><i class="fas fa-check-circle"></i> Validação</h6>
+                    
+                    <div class="mb-3">
+                        <label class="form-label">Método</label>
+                        <select id="validationMethod" class="form-select form-select-sm">
+                            <option value="llm">LLM (Automático)</option>
+                            <option value="keyword">Palavra-chave</option>
+                        </select>
+                    </div>
+
+                    <div id="keywordDiv" class="mb-3" style="display: none;">
+                        <label class="form-label">Conteúdo Esperado</label>
+                        <input type="text" id="expectedContent" class="form-control form-control-sm" 
+                               placeholder="Texto que deve aparecer na resposta">
+                    </div>
+
+                    <button id="runTests" class="btn btn-warning btn-sm w-100">
+                        <i class="fas fa-play"></i> Executar Testes
+                    </button>
+                </div>
+            </div>
+
+            <!-- Main Content -->
+            <div class="col-md-9 main-content">
+                <div class="dashboard-header">
+                    <div class="d-flex justify-content-between align-items-center">
+                        <h2><i class="fas fa-chart-line"></i> Dashboard de Testes</h2>
+                        <div id="sessionStatus" class="status-badge status-idle">
+                            <i class="fas fa-circle"></i> Aguardando
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Session Info -->
+                <div id="sessionInfo" class="alert alert-info" style="display: none;">
+                    <h6><i class="fas fa-info-circle"></i> Informações da Sessão</h6>
+                    <div id="sessionDetails"></div>
+                </div>
+
+                <!-- Test Groups -->
+                <div id="testGroups">
+                    <h5><i class="fas fa-layer-group"></i> Grupos de Teste</h5>
+                    <div id="groupsList">
+                        <p class="text-muted">Nenhum grupo configurado ainda.</p>
+                    </div>
+                </div>
+
+                <!-- Progress -->
+                <div id="progressContainer" class="progress-container">
+                    <h5><i class="fas fa-tasks"></i> Progresso dos Testes</h5>
+                    <div class="progress mb-3">
+                        <div id="progressBar" class="progress-bar progress-bar-striped progress-bar-animated" 
+                             role="progressbar" style="width: 0%"></div>
+                    </div>
+                    <div id="progressDetails" class="row">
+                        <div class="col-md-3">
+                            <div class="metric-card">
+                                <div class="metric-value" id="completedTests">0</div>
+                                <div class="metric-label">Testes Concluídos</div>
+                            </div>
+                        </div>
+                        <div class="col-md-3">
+                            <div class="metric-card">
+                                <div class="metric-value" id="totalTests">0</div>
+                                <div class="metric-label">Total de Testes</div>
+                            </div>
+                        </div>
+                        <div class="col-md-3">
+                            <div class="metric-card">
+                                <div class="metric-value" id="currentGroup">-</div>
+                                <div class="metric-label">Grupo Atual</div>
+                            </div>
+                        </div>
+                        <div class="col-md-3">
+                            <div class="metric-card">
+                                <div class="metric-value" id="estimatedTime">-</div>
+                                <div class="metric-label">Tempo Restante</div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Controles de Cancelamento -->
+                    <div class="card mt-3">
+                        <div class="card-header">
+                            <h6><i class="fas fa-stop-circle"></i> Controles de Teste</h6>
+                        </div>
+                        <div class="card-body">
+                            <div class="row">
+                                <div class="col-md-6">
+                                    <div id="currentTestInfo" class="mb-3">
+                                        <strong>Teste Atual:</strong>
+                                        <div id="currentTestDetails" class="text-muted">Nenhum teste em execução</div>
+                                    </div>
+                                    <div id="runningTestsInfo" class="mb-3">
+                                        <strong>Testes em Execução:</strong>
+                                        <span id="runningTestsCount" class="badge bg-primary">0</span>
+                                    </div>
+                                </div>
+                                <div class="col-md-6">
+                                    <div class="d-grid gap-2">
+                                        <button id="cancelCurrentBtn" class="btn btn-warning btn-sm" onclick="cancelCurrentTest()">
+                                            <i class="fas fa-stop"></i> Cancelar Teste Atual
+                                        </button>
+                                        <button id="skipStuckBtn" class="btn btn-danger btn-sm" onclick="skipStuckTests()">
+                                            <i class="fas fa-forward"></i> Pular Testes Travados (>2min)
+                                        </button>
+                                        <button id="cancelAllBtn" class="btn btn-dark btn-sm" onclick="cancelAllTests()">
+                                            <i class="fas fa-ban"></i> Cancelar Todos os Testes
+                                        </button>
+                                    </div>
+                                </div>
+                            </div>
+
+                            <!-- Lista de Testes em Execução -->
+                            <div id="runningTestsList" class="mt-3" style="display: none;">
+                                <h6>Testes em Execução:</h6>
+                                <div id="runningTestsContainer" class="list-group">
+                                    <!-- Preenchido dinamicamente -->
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <!-- Results -->
+                <div id="resultsContainer" class="results-container">
+                    <div class="d-flex justify-content-between align-items-center mb-3">
+                        <h5><i class="fas fa-chart-bar"></i> Resultados</h5>
+                        <button id="downloadCsv" class="btn btn-outline-primary btn-sm">
+                            <i class="fas fa-download"></i> Baixar CSV
+                        </button>
+                    </div>
+                    
+                    <!-- Tabs -->
+                    <ul class="nav nav-tabs" id="resultsTabs" role="tablist">
+                        <li class="nav-item" role="presentation">
+                            <button class="nav-link active" id="summary-tab" data-bs-toggle="tab" 
+                                    data-bs-target="#summary" type="button" role="tab">
+                                <i class="fas fa-chart-pie"></i> Resumo
+                            </button>
+                        </li>
+                        <li class="nav-item" role="presentation">
+                            <button class="nav-link" id="groups-tab" data-bs-toggle="tab" 
+                                    data-bs-target="#groups" type="button" role="tab">
+                                <i class="fas fa-layer-group"></i> Por Grupo
+                            </button>
+                        </li>
+                        <li class="nav-item" role="presentation">
+                            <button class="nav-link" id="individual-tab" data-bs-toggle="tab" 
+                                    data-bs-target="#individual" type="button" role="tab">
+                                <i class="fas fa-list"></i> Individual
+                            </button>
+                        </li>
+                    </ul>
+                    
+                    <div class="tab-content" id="resultsTabContent">
+                        <div class="tab-pane fade show active" id="summary" role="tabpanel">
+                            <div id="summaryContent" class="p-3"></div>
+                        </div>
+                        <div class="tab-pane fade" id="groups" role="tabpanel">
+                            <div id="groupsContent" class="p-3"></div>
+                        </div>
+                        <div class="tab-pane fade" id="individual" role="tabpanel">
+                            <div id="individualContent" class="p-3"></div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- Scripts -->
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.1.3/dist/js/bootstrap.bundle.min.js"></script>
+    <script src="{{ url_for('static', filename='js/app.js') }}"></script>
+</body>
+</html>

testes/test_runner.py

@@ -0,0 +1,673 @@
+#!/usr/bin/env python3
+"""
+Sistema de execução massiva de testes com paralelismo
+"""
+import asyncio
+import logging
+import time
+import threading
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+import uuid
+import sys
+import os
+
+# Adiciona path do projeto
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from graphs.main_graph import AgentGraphManager
+from testes.test_validator import TestValidator
+from utils.config import AVAILABLE_MODELS
+
+class MassiveTestRunner:
+    """
+    Executor de testes massivos com paralelismo otimizado
+    """
+    
+    def __init__(self, max_workers: int = 5):
+        """
+        Inicializa o test runner
+
+        Args:
+            max_workers: Número máximo de workers paralelos
+        """
+        self.max_workers = max_workers
+        logging.info(f"🔧 MassiveTestRunner inicializado com {max_workers} workers paralelos")
+        self.validator = TestValidator()
+        self.results = {
+            'session_info': {},
+            'group_results': [],
+            'individual_results': [],
+            'summary': {}
+        }
+        self.status = {
+            'current_status': 'idle',
+            'progress': 0,
+            'current_group': None,
+            'completed_tests': 0,
+            'total_tests': 0,
+            'start_time': None,
+            'estimated_remaining': None,
+            'errors': [],
+            'current_test': None,
+            'running_tests': {},  # {thread_id: {start_time, group_id, iteration, task, future}}
+            'cancelled_tests': set(),
+            'timeout_tests': set()
+        }
+        self._lock = threading.Lock()
+        self._cancel_event = threading.Event()
+        self._test_timeout = 360  # 1.5 minutos timeout por teste
+        self._active_futures = {}  # {thread_id: future} para cancelamento real
+        
+    async def run_test_session(self, session: Dict[str, Any], validation_method: str = 'llm', expected_content: str = None) -> Dict[str, Any]:
+        """
+        Executa sessão completa de testes
+        
+        Args:
+            session: Dados da sessão de teste
+            validation_method: Método de validação ('llm' ou 'keyword')
+            expected_content: Conteúdo esperado (para validação keyword)
+            
+        Returns:
+            Resultados completos dos testes
+        """
+        try:
+            print(f"\n🔥 MASSIVE TEST RUNNER INICIADO")
+            print(f"📋 Sessão: {session['id']}")
+            print(f"❓ Pergunta: {session['question']}")
+            print(f"👥 Grupos: {len(session['groups'])}")
+
+            total_tests = sum(group['iterations'] for group in session['groups'])
+            print(f"🔢 Total de testes: {total_tests}")
+            print(f"⚡ Workers paralelos: {self.max_workers}")
+            print("-" * 60)
+
+            logging.info(f"🚀 Iniciando sessão de testes: {session['id']}")
+
+            # Atualiza status
+            with self._lock:
+                self.status.update({
+                    'current_status': 'initializing',
+                    'start_time': time.time(),
+                    'total_tests': total_tests
+                })
+            
+            # Armazena informações da sessão
+            self.results['session_info'] = {
+                'id': session['id'],
+                'question': session['question'],
+                'validation_method': validation_method,
+                'expected_content': expected_content,
+                'total_groups': len(session['groups']),
+                'total_tests': self.status['total_tests'],
+                'started_at': datetime.now().isoformat()
+            }
+            
+            # Executa grupos de teste
+            group_results = []
+            
+            for group_idx, group in enumerate(session['groups']):
+                print(f"\n📊 EXECUTANDO GRUPO {group_idx + 1}/{len(session['groups'])}")
+                print(f"🤖 Modelo SQL: {group['sql_model_name']}")
+                print(f"🔄 Processing Agent: {'✅ ' + group['processing_model_name'] if group['processing_enabled'] else '❌ Desativado'}")
+                print(f"🔢 Iterações: {group['iterations']}")
+                print(f"⏰ {datetime.now().strftime('%H:%M:%S')}")
+
+                logging.info(f"📊 Executando grupo {group_idx + 1}/{len(session['groups'])}: {group['sql_model_name']}")
+
+                with self._lock:
+                    self.status['current_group'] = group_idx + 1
+                    self.status['current_status'] = 'running_group'
+                
+                # Executa testes do grupo em paralelo
+                group_result = await self._run_group_tests(
+                    session['question'],
+                    group,
+                    validation_method,
+                    expected_content
+                )
+                
+                group_results.append(group_result)
+                self.results['group_results'] = group_results
+                
+                # Atualiza progresso
+                completed_so_far = sum(len(gr['individual_results']) for gr in group_results)
+                with self._lock:
+                    self.status['completed_tests'] = completed_so_far
+                    self.status['progress'] = (completed_so_far / self.status['total_tests']) * 100
+                    
+                    # Estima tempo restante
+                    if self.status['start_time']:
+                        elapsed = time.time() - self.status['start_time']
+                        if completed_so_far > 0:
+                            avg_time_per_test = elapsed / completed_so_far
+                            remaining_tests = self.status['total_tests'] - completed_so_far
+                            self.status['estimated_remaining'] = avg_time_per_test * remaining_tests
+            
+            # Gera resumo final
+            self._generate_summary()
+
+            with self._lock:
+                self.status['current_status'] = 'completed'
+                self.status['progress'] = 100
+                self.status['end_time'] = time.time()
+                total_time = self.status['end_time'] - self.status['start_time']
+                self.status['total_execution_time'] = total_time
+
+            logging.info(f"✅ Sessão de testes concluída: {session['id']}")
+            logging.info(f"📊 Resumo final: {self.status['total_tests']} testes em {total_time:.2f}s")
+            logging.info(f"🎯 Taxa geral de sucesso: {self.results['summary'].get('overall_success_rate', 0)}%")
+
+            return self.results
+            
+        except Exception as e:
+            logging.error(f"❌ Erro na sessão de testes: {e}")
+            with self._lock:
+                self.status['current_status'] = 'error'
+                self.status['errors'].append(str(e))
+            raise
+    
+    async def _run_group_tests(self, question: str, group: Dict[str, Any], validation_method: str, expected_content: str) -> Dict[str, Any]:
+        """
+        Executa testes de um grupo específico com paralelismo REAL
+
+        Args:
+            question: Pergunta do teste
+            group: Configuração do grupo
+            validation_method: Método de validação
+            expected_content: Conteúdo esperado
+
+        Returns:
+            Resultados do grupo
+        """
+        print(f"🔄 Executando {group['iterations']} testes em paralelo (máx {self.max_workers} simultâneos)")
+        logging.info(f"🔄 Executando {group['iterations']} testes para grupo {group['id']}")
+
+        # Cria semáforo para controle de concorrência
+        semaphore = asyncio.Semaphore(self.max_workers)
+
+        print(f"⚡ Iniciando {group['iterations']} testes com paralelismo REAL...")
+        start_time = time.time()
+
+        # VOLTA AO PARALELISMO ORIGINAL QUE FUNCIONAVA
+        print(f"🚀 Executando {group['iterations']} testes em paralelo (máx {self.max_workers} simultâneos)")
+
+        # Cria tasks para execução paralela (COMO ESTAVA ANTES)
+        semaphore = asyncio.Semaphore(self.max_workers)
+        tasks = []
+
+        print(f"⚡ Criando {group['iterations']} tasks paralelas...")
+        for iteration in range(group['iterations']):
+            task = self._run_single_test(
+                semaphore,
+                question,
+                group,
+                iteration + 1,
+                validation_method,
+                expected_content
+            )
+            tasks.append(task)
+
+        print(f"🚀 Executando {len(tasks)} testes em paralelo...")
+        start_time = time.time()
+
+        # Executa testes em paralelo (COMO ESTAVA ANTES)
+        individual_results = await asyncio.gather(*tasks, return_exceptions=True)
+
+        execution_time = time.time() - start_time
+        print(f"✅ Grupo {group['id']} concluído em {execution_time:.2f}s")
+
+        execution_time = time.time() - start_time
+        print(f"✅ Grupo {group['id']} concluído em {execution_time:.2f}s ({group['iterations']} testes)")
+        
+        # Filtra resultados válidos
+        valid_results = []
+        errors = []
+        
+        for result in individual_results:
+            if isinstance(result, Exception):
+                errors.append(str(result))
+                logging.error(f"Erro em teste individual: {result}")
+            else:
+                valid_results.append(result)
+                self.results['individual_results'].append(result)
+        
+        # Calcula estatísticas do grupo
+        group_stats = self._calculate_group_stats(valid_results, group)
+        group_stats['errors'] = errors
+        group_stats['error_count'] = len(errors)
+        
+        logging.info(f"✅ Grupo {group['id']} concluído: {len(valid_results)} sucessos, {len(errors)} erros")
+        
+        return group_stats
+    
+    async def _run_single_test(self, semaphore: asyncio.Semaphore, question: str, group: Dict[str, Any],
+                              iteration: int, validation_method: str, expected_content: str) -> Dict[str, Any]:
+        """
+        Executa um teste individual com paralelismo real
+
+        Args:
+            semaphore: Semáforo para controle de concorrência
+            question: Pergunta do teste
+            group: Configuração do grupo
+            iteration: Número da iteração
+            validation_method: Método de validação
+            expected_content: Conteúdo esperado
+
+        Returns:
+            Resultado do teste individual
+        """
+        async with semaphore:
+            try:
+                start_time = time.time()
+
+                # Cria thread_id único para este teste
+                thread_id = f"test_{group['id']}_{iteration}_{uuid.uuid4().hex[:8]}"
+
+                # Registra teste como em execução
+                with self._lock:
+                    self.status['running_tests'][thread_id] = {
+                        'start_time': start_time,
+                        'group_id': group['id'],
+                        'iteration': iteration,
+                        'question': question[:50] + '...' if len(question) > 50 else question
+                    }
+                    self.status['current_test'] = thread_id
+
+                print(f"🔄 [{datetime.now().strftime('%H:%M:%S')}] 🚀 INICIANDO {thread_id} (Worker {asyncio.current_task().get_name() if asyncio.current_task() else 'unknown'})")
+                logging.info(f"🔄 Iniciando teste {thread_id} - Grupo {group['id']}, Iteração {iteration}")
+
+                # Verifica se foi cancelado antes de começar
+                if thread_id in self.status['cancelled_tests']:
+                    print(f"🚫 Teste {thread_id} cancelado antes de iniciar")
+                    return self._create_cancelled_result(thread_id, group, iteration, start_time)
+
+                # Registra task para cancelamento (NOVO)
+                current_task = asyncio.current_task()
+                with self._lock:
+                    self._active_futures[thread_id] = current_task
+
+                # Executa em thread separada para paralelismo real (COMO ESTAVA ANTES)
+                loop = asyncio.get_event_loop()
+
+                def run_sync_test():
+                    """Executa teste de forma síncrona em thread separada"""
+                    try:
+                        # Verifica cancelamento antes de iniciar (NOVO)
+                        if thread_id in self.status['cancelled_tests']:
+                            return {'cancelled': True, 'reason': 'cancelled_before_start'}
+
+                        # Cria novo loop para esta thread
+                        new_loop = asyncio.new_event_loop()
+                        asyncio.set_event_loop(new_loop)
+
+                        # Inicializa AgentGraphManager para este teste
+                        graph_manager = AgentGraphManager()
+
+                        # Executa query
+                        result = new_loop.run_until_complete(
+                            graph_manager.process_query(
+                                user_input=question,
+                                selected_model=group['sql_model_name'],
+                                processing_enabled=group['processing_enabled'],
+                                processing_model=group['processing_model_name'] if group['processing_enabled'] else None,
+                                thread_id=thread_id
+                            )
+                        )
+
+                        new_loop.close()
+
+                        # Verifica cancelamento após execução (NOVO)
+                        if thread_id in self.status['cancelled_tests']:
+                            return {'cancelled': True, 'reason': 'cancelled_after_execution'}
+
+                        return result
+
+                    except Exception as e:
+                        logging.error(f"Erro em thread separada para {thread_id}: {e}")
+                        return {'error': str(e)}
+
+                # Executa em ThreadPoolExecutor para paralelismo real (COMO ESTAVA ANTES)
+                with ThreadPoolExecutor(max_workers=1) as executor:
+                    future = loop.run_in_executor(executor, run_sync_test)
+
+                    # Aguarda com verificação de cancelamento (NOVO)
+                    while not future.done():
+                        await asyncio.sleep(0.1)  # Verifica a cada 100ms
+                        if thread_id in self.status['cancelled_tests']:
+                            future.cancel()
+                            print(f"🚫 Cancelando future do teste {thread_id}")
+                            try:
+                                await future
+                            except:
+                                pass
+                            return self._create_cancelled_result(thread_id, group, iteration, start_time, 'user_cancelled')
+
+                    result = await future
+
+                execution_time = time.time() - start_time
+
+                # Remove teste da lista de execução e limpa future
+                with self._lock:
+                    if thread_id in self.status['running_tests']:
+                        del self.status['running_tests'][thread_id]
+                    if self.status['current_test'] == thread_id:
+                        self.status['current_test'] = None
+                    if thread_id in self._active_futures:
+                        del self._active_futures[thread_id]
+
+                # Verifica tipo de resultado
+                if isinstance(result, dict):
+                    if result.get('cancelled'):
+                        print(f"🚫 [{datetime.now().strftime('%H:%M:%S')}] CANCELADO {thread_id} - {result.get('reason', 'unknown')}")
+                        logging.info(f"🚫 Teste {thread_id} cancelado")
+                        return self._create_cancelled_result(thread_id, group, iteration, start_time, result.get('reason'))
+                    elif result.get('timeout'):
+                        print(f"⏰ [{datetime.now().strftime('%H:%M:%S')}] TIMEOUT {thread_id} após {result.get('duration')}s")
+                        logging.warning(f"⏰ Teste {thread_id} timeout")
+                        return self._create_timeout_result(thread_id, group, iteration, start_time, result.get('duration'))
+                    elif result.get('error'):
+                        print(f"❌ [{datetime.now().strftime('%H:%M:%S')}] ERRO {thread_id}: {result['error']}")
+                        logging.error(f"❌ Teste {thread_id} erro: {result['error']}")
+
+                print(f"✅ [{datetime.now().strftime('%H:%M:%S')}] 🎉 CONCLUÍDO {thread_id} em {execution_time:.2f}s")
+                logging.info(f"✅ Teste {thread_id} concluído em {execution_time:.2f}s")
+
+                # Valida resultado
+                validation_result = await self.validator.validate_result(
+                    question=question,
+                    sql_query=result.get('sql_query_extracted', ''),
+                    response=result.get('response', ''),
+                    method=validation_method,
+                    expected_content=expected_content
+                )
+
+                # Monta resultado individual
+                individual_result = {
+                    'group_id': group['id'],
+                    'iteration': iteration,
+                    'thread_id': thread_id,
+                    'timestamp': datetime.now().isoformat(),
+                    'execution_time': round(execution_time, 2),
+                    'question': question,
+                    'sql_model': group['sql_model_name'],
+                    'processing_enabled': group['processing_enabled'],
+                    'processing_model': group['processing_model_name'],
+                    'sql_query': result.get('sql_query_extracted', ''),
+                    'response': result.get('response', ''),
+                    'error': result.get('error'),
+                    'success': not bool(result.get('error')),
+                    'validation': validation_result
+                }
+
+                # Atualiza progresso
+                with self._lock:
+                    self.status['completed_tests'] += 1
+                    progress = (self.status['completed_tests'] / self.status['total_tests']) * 100
+                    self.status['progress'] = progress
+
+                    # Estima tempo restante
+                    if self.status['start_time']:
+                        elapsed = time.time() - self.status['start_time']
+                        if self.status['completed_tests'] > 0:
+                            avg_time_per_test = elapsed / self.status['completed_tests']
+                            remaining_tests = self.status['total_tests'] - self.status['completed_tests']
+                            self.status['estimated_remaining'] = avg_time_per_test * remaining_tests
+
+                            # Print visual do progresso
+                            remaining_min = int(self.status['estimated_remaining'] // 60)
+                            remaining_sec = int(self.status['estimated_remaining'] % 60)
+
+                            print(f"📊 [{datetime.now().strftime('%H:%M:%S')}] Progresso: {self.status['completed_tests']}/{self.status['total_tests']} ({progress:.1f}%) - Restam ~{remaining_min}m{remaining_sec}s")
+
+                logging.info(f"📊 Progresso: {self.status['completed_tests']}/{self.status['total_tests']} ({progress:.1f}%)")
+
+                return individual_result
+
+            except Exception as e:
+                logging.error(f"❌ Erro em teste individual (grupo {group['id']}, iteração {iteration}): {e}")
+
+                # Atualiza progresso mesmo com erro
+                with self._lock:
+                    self.status['completed_tests'] += 1
+                    self.status['errors'].append(f"Grupo {group['id']}, Iteração {iteration}: {e}")
+
+                return {
+                    'group_id': group['id'],
+                    'iteration': iteration,
+                    'thread_id': f"error_{group['id']}_{iteration}",
+                    'timestamp': datetime.now().isoformat(),
+                    'execution_time': time.time() - start_time,
+                    'question': question,
+                    'sql_model': group['sql_model_name'],
+                    'processing_enabled': group['processing_enabled'],
+                    'processing_model': group['processing_model_name'],
+                    'sql_query': '',
+                    'response': '',
+                    'error': str(e),
+                    'success': False,
+                    'validation': {'valid': False, 'score': 0, 'reason': f'Erro de execução: {e}'}
+                }
+    
+    def _calculate_group_stats(self, results: List[Dict[str, Any]], group: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Calcula estatísticas de um grupo
+        
+        Args:
+            results: Resultados individuais do grupo
+            group: Configuração do grupo
+            
+        Returns:
+            Estatísticas do grupo
+        """
+        if not results:
+            return {
+                'group_id': group['id'],
+                'group_config': group,
+                'total_tests': 0,
+                'success_rate': 0,
+                'validation_rate': 0,
+                'consistency_rate': 0,
+                'avg_execution_time': 0,
+                'individual_results': []
+            }
+        
+        total_tests = len(results)
+        successful_tests = sum(1 for r in results if r.get('success', False))
+        valid_responses = sum(1 for r in results if r.get('validation', {}).get('valid', False))
+        
+        # Calcula consistência (respostas similares)
+        responses = [r.get('response', '') for r in results if r.get('success', False)]
+        sql_queries = [r.get('sql_query', '') for r in results if r.get('success', False)]
+        
+        response_consistency = self._calculate_consistency(responses)
+        sql_consistency = self._calculate_consistency(sql_queries)
+        
+        avg_execution_time = sum(r.get('execution_time', 0) for r in results) / total_tests
+        
+        return {
+            'group_id': group['id'],
+            'group_config': group,
+            'total_tests': total_tests,
+            'successful_tests': successful_tests,
+            'valid_responses': valid_responses,
+            'success_rate': round((successful_tests / total_tests) * 100, 2),
+            'validation_rate': round((valid_responses / total_tests) * 100, 2),
+            'response_consistency': round(response_consistency * 100, 2),
+            'sql_consistency': round(sql_consistency * 100, 2),
+            'avg_execution_time': round(avg_execution_time, 2),
+            'individual_results': results
+        }
+    
+    def _calculate_consistency(self, items: List[str]) -> float:
+        """
+        Calcula taxa de consistência entre itens
+        
+        Args:
+            items: Lista de strings para comparar
+            
+        Returns:
+            Taxa de consistência (0-1)
+        """
+        if len(items) <= 1:
+            return 1.0
+        
+        # Conta ocorrências únicas
+        unique_items = set(items)
+        most_common_count = max(items.count(item) for item in unique_items)
+        
+        return most_common_count / len(items)
+    
+    def _generate_summary(self):
+        """Gera resumo geral dos testes"""
+        group_results = self.results.get('group_results', [])
+        
+        if not group_results:
+            self.results['summary'] = {}
+            return
+        
+        total_tests = sum(gr['total_tests'] for gr in group_results)
+        total_successful = sum(gr['successful_tests'] for gr in group_results)
+        total_valid = sum(gr['valid_responses'] for gr in group_results)
+        
+        avg_success_rate = sum(gr['success_rate'] for gr in group_results) / len(group_results)
+        avg_validation_rate = sum(gr['validation_rate'] for gr in group_results) / len(group_results)
+        avg_response_consistency = sum(gr['response_consistency'] for gr in group_results) / len(group_results)
+        avg_sql_consistency = sum(gr['sql_consistency'] for gr in group_results) / len(group_results)
+        
+        self.results['summary'] = {
+            'total_groups': len(group_results),
+            'total_tests': total_tests,
+            'total_successful': total_successful,
+            'total_valid': total_valid,
+            'overall_success_rate': round((total_successful / total_tests) * 100, 2),
+            'overall_validation_rate': round((total_valid / total_tests) * 100, 2),
+            'avg_response_consistency': round(avg_response_consistency, 2),
+            'avg_sql_consistency': round(avg_sql_consistency, 2),
+            'best_performing_group': max(group_results, key=lambda x: x['validation_rate']),
+            'most_consistent_group': max(group_results, key=lambda x: x['response_consistency'])
+        }
+    
+    def get_status(self) -> Dict[str, Any]:
+        """Retorna status atual dos testes"""
+        with self._lock:
+            status = self.status.copy()
+            # Adiciona informações dos testes em execução
+            status['running_tests_count'] = len(self.status['running_tests'])
+            status['running_tests_details'] = list(self.status['running_tests'].values())
+            return status
+
+    def cancel_current_test(self, thread_id: str = None) -> bool:
+        """
+        Cancela teste específico ou o mais antigo em execução
+
+        Args:
+            thread_id: ID do teste específico para cancelar (opcional)
+
+        Returns:
+            True se cancelou algum teste
+        """
+        with self._lock:
+            if thread_id:
+                if thread_id in self.status['running_tests']:
+                    self.status['cancelled_tests'].add(thread_id)
+                    print(f"🚫 Teste {thread_id} marcado para cancelamento")
+                    logging.info(f"Teste {thread_id} cancelado pelo usuário")
+                    return True
+            else:
+                # Cancela o teste mais antigo
+                if self.status['running_tests']:
+                    oldest_test = min(
+                        self.status['running_tests'].items(),
+                        key=lambda x: x[1]['start_time']
+                    )
+                    thread_id = oldest_test[0]
+                    self.status['cancelled_tests'].add(thread_id)
+                    print(f"🚫 Teste mais antigo {thread_id} marcado para cancelamento")
+                    logging.info(f"Teste mais antigo {thread_id} cancelado pelo usuário")
+                    return True
+        return False
+
+    def cancel_all_tests(self) -> int:
+        """
+        Cancela todos os testes em execução
+
+        Returns:
+            Número de testes cancelados
+        """
+        with self._lock:
+            running_count = len(self.status['running_tests'])
+            for thread_id in self.status['running_tests'].keys():
+                self.status['cancelled_tests'].add(thread_id)
+
+            print(f"🚫 {running_count} testes marcados para cancelamento")
+            logging.info(f"{running_count} testes cancelados pelo usuário")
+            return running_count
+
+    def skip_stuck_tests(self, max_duration: int = 120) -> int:
+        """
+        Marca testes travados (que excedem tempo limite) para cancelamento
+
+        Args:
+            max_duration: Tempo máximo em segundos
+
+        Returns:
+            Número de testes marcados como travados
+        """
+        current_time = time.time()
+        stuck_count = 0
+
+        with self._lock:
+            for thread_id, test_info in self.status['running_tests'].items():
+                if current_time - test_info['start_time'] > max_duration:
+                    if thread_id not in self.status['cancelled_tests']:
+                        self.status['timeout_tests'].add(thread_id)
+                        self.status['cancelled_tests'].add(thread_id)
+                        stuck_count += 1
+                        print(f"⏰ Teste {thread_id} marcado como travado (>{max_duration}s)")
+                        logging.warning(f"Teste {thread_id} travado - timeout após {max_duration}s")
+
+        return stuck_count
+
+    def _create_cancelled_result(self, thread_id: str, group: Dict[str, Any], iteration: int, start_time: float, reason: str = 'user_cancelled') -> Dict[str, Any]:
+        """Cria resultado para teste cancelado"""
+        execution_time = time.time() - start_time
+        return {
+            'thread_id': thread_id,
+            'group_id': group['id'],
+            'iteration': iteration,
+            'success': False,
+            'cancelled': True,
+            'cancel_reason': reason,
+            'execution_time': execution_time,
+            'sql_query': None,
+            'final_response': f"Teste cancelado: {reason}",
+            'validation_valid': False,
+            'validation_score': 0,
+            'error': None,
+            'timestamp': datetime.now().isoformat()
+        }
+
+    def _create_timeout_result(self, thread_id: str, group: Dict[str, Any], iteration: int, start_time: float, duration: int) -> Dict[str, Any]:
+        """Cria resultado para teste com timeout"""
+        execution_time = time.time() - start_time
+        return {
+            'thread_id': thread_id,
+            'group_id': group['id'],
+            'iteration': iteration,
+            'success': False,
+            'timeout': True,
+            'timeout_duration': duration,
+            'execution_time': execution_time,
+            'sql_query': None,
+            'final_response': f"Teste travado - timeout após {duration}s",
+            'validation_valid': False,
+            'validation_score': 0,
+            'error': f"Timeout após {duration}s",
+            'timestamp': datetime.now().isoformat()
+        }
+    
+    def get_results(self) -> Dict[str, Any]:
+        """Retorna resultados dos testes"""
+        return self.results

testes/test_system.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""
+Script de teste do sistema de testes massivos
+"""
+import sys
+import os
+import asyncio
+import logging
+
+# Adiciona path do projeto
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+def test_imports():
+    """Testa se todos os imports funcionam"""
+    print("🔍 Testando imports...")
+    
+    try:
+        from testes.test_runner import MassiveTestRunner
+        print("  ✅ MassiveTestRunner")
+        
+        from testes.test_validator import TestValidator
+        print("  ✅ TestValidator")
+        
+        from testes.report_generator import ReportGenerator
+        print("  ✅ ReportGenerator")
+        
+        from utils.config import AVAILABLE_MODELS
+        print("  ✅ AVAILABLE_MODELS")
+        
+        return True
+    except Exception as e:
+        print(f"  ❌ Erro no import: {e}")
+        return False
+
+def test_validator():
+    """Testa o sistema de validação"""
+    print("\n🔍 Testando validador...")
+    
+    try:
+        from testes.test_validator import TestValidator
+        
+        validator = TestValidator()
+        print("  ✅ Validator inicializado")
+        
+        # Teste de validação por keyword
+        result = validator._validate_with_keyword(
+            "A resposta contém 150 usuários no total",
+            "150 usuários"
+        )
+        
+        if result['valid'] and result['score'] == 100:
+            print("  ✅ Validação por keyword funcionando")
+        else:
+            print(f"  ❌ Validação por keyword falhou: {result}")
+            return False
+        
+        # Teste de sintaxe SQL
+        sql_result = validator.validate_sql_syntax("SELECT * FROM usuarios WHERE idade > 18")
+        
+        if sql_result['valid']:
+            print("  ✅ Validação de sintaxe SQL funcionando")
+        else:
+            print(f"  ❌ Validação SQL falhou: {sql_result}")
+            return False
+        
+        return True
+    except Exception as e:
+        print(f"  ❌ Erro no validator: {e}")
+        return False
+
+def test_report_generator():
+    """Testa o gerador de relatórios"""
+    print("\n🔍 Testando gerador de relatórios...")
+    
+    try:
+        from testes.report_generator import ReportGenerator
+        
+        generator = ReportGenerator()
+        print("  ✅ ReportGenerator inicializado")
+        
+        # Dados de teste
+        test_results = {
+            'session_info': {
+                'id': 'test_session',
+                'question': 'Teste de pergunta',
+                'validation_method': 'keyword'
+            },
+            'group_results': [
+                {
+                    'group_id': 1,
+                    'group_config': {
+                        'sql_model_name': 'GPT-4o-mini',
+                        'processing_enabled': False,
+                        'processing_model_name': None
+                    },
+                    'total_tests': 5,
+                    'successful_tests': 4,
+                    'valid_responses': 3,
+                    'success_rate': 80.0,
+                    'validation_rate': 60.0,
+                    'response_consistency': 75.0,
+                    'sql_consistency': 80.0,
+                    'avg_execution_time': 5.2
+                }
+            ],
+            'individual_results': [
+                {
+                    'group_id': 1,
+                    'iteration': 1,
+                    'sql_model': 'GPT-4o-mini',
+                    'processing_enabled': False,
+                    'success': True,
+                    'validation': {'valid': True, 'score': 85}
+                }
+            ],
+            'summary': {
+                'total_groups': 1,
+                'total_tests': 5,
+                'overall_success_rate': 80.0,
+                'overall_validation_rate': 60.0,
+                'best_performing_group': {
+                    'group_id': 1,
+                    'group_config': {'sql_model_name': 'GPT-4o-mini'},
+                    'validation_rate': 60.0
+                },
+                'most_consistent_group': {
+                    'group_id': 1,
+                    'group_config': {'sql_model_name': 'GPT-4o-mini'},
+                    'response_consistency': 75.0
+                }
+            }
+        }
+        
+        # Testa criação de DataFrames
+        group_df = generator._create_group_summary_dataframe(test_results)
+        individual_df = generator._create_individual_results_dataframe(test_results)
+        general_df = generator._create_general_summary_dataframe(test_results)
+        
+        if len(group_df) > 0 and len(individual_df) > 0 and len(general_df) > 0:
+            print("  ✅ DataFrames criados com sucesso")
+        else:
+            print("  ❌ Erro na criação de DataFrames")
+            return False
+        
+        return True
+    except Exception as e:
+        print(f"  ❌ Erro no report generator: {e}")
+        return False
+
+async def test_runner_basic():
+    """Testa funcionalidades básicas do runner"""
+    print("\n🔍 Testando runner básico...")
+    
+    try:
+        from testes.test_runner import MassiveTestRunner
+        
+        runner = MassiveTestRunner(max_workers=2)
+        print("  ✅ MassiveTestRunner inicializado")
+        
+        # Testa cálculo de consistência
+        items = ["resposta A", "resposta A", "resposta B", "resposta A"]
+        consistency = runner._calculate_consistency(items)
+        
+        expected = 3/4  # 3 "resposta A" de 4 total
+        if abs(consistency - expected) < 0.01:
+            print("  ✅ Cálculo de consistência funcionando")
+        else:
+            print(f"  ❌ Consistência incorreta: esperado {expected}, obtido {consistency}")
+            return False
+        
+        # Testa status
+        status = runner.get_status()
+        if 'current_status' in status and status['current_status'] == 'idle':
+            print("  ✅ Status funcionando")
+        else:
+            print(f"  ❌ Status incorreto: {status}")
+            return False
+        
+        return True
+    except Exception as e:
+        print(f"  ❌ Erro no runner: {e}")
+        return False
+
+def test_flask_app():
+    """Testa se o app Flask pode ser importado"""
+    print("\n🔍 Testando Flask app...")
+    
+    try:
+        from testes.app_teste import app
+        print("  ✅ Flask app importado")
+        
+        # Testa se as rotas estão definidas
+        routes = [rule.rule for rule in app.url_map.iter_rules()]
+        expected_routes = ['/', '/api/models', '/api/create_test_session']
+        
+        for route in expected_routes:
+            if route in routes:
+                print(f"  ✅ Rota {route} definida")
+            else:
+                print(f"  ❌ Rota {route} não encontrada")
+                return False
+        
+        return True
+    except Exception as e:
+        print(f"  ❌ Erro no Flask app: {e}")
+        return False
+
+def test_agentgraph_integration():
+    """Testa integração com AgentGraph"""
+    print("\n🔍 Testando integração com AgentGraph...")
+    
+    try:
+        from utils.config import AVAILABLE_MODELS, validate_config
+        
+        # Testa se modelos estão disponíveis
+        if len(AVAILABLE_MODELS) > 0:
+            print(f"  ✅ {len(AVAILABLE_MODELS)} modelos disponíveis")
+        else:
+            print("  ❌ Nenhum modelo disponível")
+            return False
+        
+        # Testa validação de config (pode falhar se APIs não configuradas)
+        try:
+            validate_config()
+            print("  ✅ Configuração válida")
+        except Exception as e:
+            print(f"  ⚠️ Configuração incompleta: {e}")
+            print("  💡 Configure as APIs no .env para funcionalidade completa")
+        
+        return True
+    except Exception as e:
+        print(f"  ❌ Erro na integração: {e}")
+        return False
+
+async def main():
+    """Função principal de teste"""
+    print("🧪 TESTE DO SISTEMA DE TESTES MASSIVOS")
+    print("=" * 50)
+    
+    tests = [
+        ("Imports", test_imports),
+        ("Validator", test_validator),
+        ("Report Generator", test_report_generator),
+        ("Runner Básico", test_runner_basic),
+        ("Flask App", test_flask_app),
+        ("Integração AgentGraph", test_agentgraph_integration)
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test_name, test_func in tests:
+        print(f"\n📋 {test_name}")
+        print("-" * 30)
+        
+        try:
+            if asyncio.iscoroutinefunction(test_func):
+                result = await test_func()
+            else:
+                result = test_func()
+            
+            if result:
+                passed += 1
+                print(f"✅ {test_name} PASSOU")
+            else:
+                print(f"❌ {test_name} FALHOU")
+        except Exception as e:
+            print(f"❌ {test_name} ERRO: {e}")
+    
+    print("\n" + "=" * 50)
+    print(f"📊 RESULTADO FINAL: {passed}/{total} testes passaram")
+    
+    if passed == total:
+        print("🎉 TODOS OS TESTES PASSARAM!")
+        print("🚀 Sistema pronto para uso!")
+        print("💡 Execute: python testes/run_tests.py")
+    else:
+        print("⚠️ Alguns testes falharam")
+        print("🔧 Verifique os erros acima")
+    
+    print("=" * 50)
+    
+    return passed == total
+
+if __name__ == '__main__':
+    success = asyncio.run(main())
+    sys.exit(0 if success else 1)

testes/test_validator.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python3
+"""
+Sistema de validação de resultados de testes
+"""
+import logging
+import re
+import asyncio
+from typing import Dict, Any, Optional
+import sys
+import os
+
+# Adiciona path do projeto
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+from langchain.schema import HumanMessage
+from utils.config import OPENAI_MODELS, ANTHROPIC_MODELS
+
+class TestValidator:
+    """
+    Validador de resultados de testes usando LLM ou keywords
+    """
+    
+    def __init__(self, validator_model: str = "gpt-4o-mini"):
+        """
+        Inicializa o validador
+        
+        Args:
+            validator_model: Modelo LLM para validação
+        """
+        self.validator_model = validator_model
+        self.llm = self._initialize_validator_llm()
+        
+    def _initialize_validator_llm(self):
+        """Inicializa LLM para validação"""
+        try:
+            if self.validator_model in OPENAI_MODELS:
+                return ChatOpenAI(
+                    model=self.validator_model,
+                    temperature=0.1,  # Baixa temperatura para consistência
+                    max_tokens=1000
+                )
+            elif self.validator_model in ANTHROPIC_MODELS:
+                return ChatAnthropic(
+                    model=self.validator_model,
+                    temperature=0.1,
+                    max_tokens=1000
+                )
+            else:
+                # Fallback para GPT-4o-mini
+                logging.warning(f"Modelo {self.validator_model} não suportado, usando gpt-4o-mini")
+                return ChatOpenAI(
+                    model="gpt-4o-mini",
+                    temperature=0.1,
+                    max_tokens=1000
+                )
+        except Exception as e:
+            logging.error(f"Erro ao inicializar LLM validador: {e}")
+            return None
+    
+    async def validate_result(self, question: str, sql_query: str, response: str, 
+                            method: str = 'llm', expected_content: str = None) -> Dict[str, Any]:
+        """
+        Valida resultado de um teste
+        
+        Args:
+            question: Pergunta original
+            sql_query: Query SQL gerada
+            response: Resposta final do agente
+            method: Método de validação ('llm' ou 'keyword')
+            expected_content: Conteúdo esperado (para método keyword)
+            
+        Returns:
+            Resultado da validação
+        """
+        try:
+            if method == 'llm':
+                return await self._validate_with_llm(question, sql_query, response)
+            elif method == 'keyword':
+                return self._validate_with_keyword(response, expected_content)
+            else:
+                return {
+                    'valid': False,
+                    'score': 0,
+                    'reason': f'Método de validação inválido: {method}',
+                    'method': method
+                }
+        except Exception as e:
+            logging.error(f"Erro na validação: {e}")
+            return {
+                'valid': False,
+                'score': 0,
+                'reason': f'Erro na validação: {e}',
+                'method': method
+            }
+    
+    async def _validate_with_llm(self, question: str, sql_query: str, response: str) -> Dict[str, Any]:
+        """
+        Valida usando LLM
+        
+        Args:
+            question: Pergunta original
+            sql_query: Query SQL gerada
+            response: Resposta final
+            
+        Returns:
+            Resultado da validação
+        """
+        if not self.llm:
+            return {
+                'valid': False,
+                'score': 0,
+                'reason': 'LLM validador não disponível',
+                'method': 'llm'
+            }
+        
+        try:
+            # Prompt para validação
+            validation_prompt = f"""
+Você é um especialista em SQL e análise de dados. Sua tarefa é avaliar se uma resposta gerada por um agente SQL está correta e adequada.
+
+PERGUNTA ORIGINAL:
+{question}
+
+QUERY SQL GERADA:
+{sql_query}
+
+RESPOSTA FINAL:
+{response}
+
+CRITÉRIOS DE AVALIAÇÃO:
+1. A query SQL está sintaticamente correta?
+2. A query SQL responde adequadamente à pergunta?
+3. A resposta final é coerente com a query e a pergunta?
+4. A resposta contém informações relevantes e úteis?
+5. Há erros evidentes na lógica ou execução?
+
+INSTRUÇÕES:
+- Analise cuidadosamente cada critério
+- Dê uma pontuação de 0 a 100
+- Considere válida (True) se pontuação >= 70
+- Seja rigoroso mas justo na avaliação
+
+RESPONDA EXATAMENTE NESTE FORMATO:
+PONTUAÇÃO: [número de 0 a 100]
+VÁLIDA: [True ou False]
+RAZÃO: [explicação breve da avaliação]
+"""
+            
+            # Executa validação
+            message = HumanMessage(content=validation_prompt)
+            response_llm = await self.llm.ainvoke([message])
+            
+            # Extrai resultado
+            return self._parse_llm_validation(response_llm.content)
+            
+        except Exception as e:
+            logging.error(f"Erro na validação LLM: {e}")
+            return {
+                'valid': False,
+                'score': 0,
+                'reason': f'Erro na validação LLM: {e}',
+                'method': 'llm'
+            }
+    
+    def _parse_llm_validation(self, llm_response: str) -> Dict[str, Any]:
+        """
+        Extrai resultado da validação LLM
+        
+        Args:
+            llm_response: Resposta do LLM
+            
+        Returns:
+            Resultado parseado
+        """
+        try:
+            # Padrões para extrair informações
+            score_pattern = r'PONTUAÇÃO:\s*(\d+)'
+            valid_pattern = r'VÁLIDA:\s*(True|False)'
+            reason_pattern = r'RAZÃO:\s*(.+?)(?:\n|$)'
+            
+            # Extrai pontuação
+            score_match = re.search(score_pattern, llm_response, re.IGNORECASE)
+            score = int(score_match.group(1)) if score_match else 0
+            
+            # Extrai validade
+            valid_match = re.search(valid_pattern, llm_response, re.IGNORECASE)
+            valid = valid_match.group(1).lower() == 'true' if valid_match else False
+            
+            # Extrai razão
+            reason_match = re.search(reason_pattern, llm_response, re.IGNORECASE | re.DOTALL)
+            reason = reason_match.group(1).strip() if reason_match else 'Sem razão fornecida'
+            
+            return {
+                'valid': valid,
+                'score': score,
+                'reason': reason,
+                'method': 'llm',
+                'raw_response': llm_response
+            }
+            
+        except Exception as e:
+            logging.error(f"Erro ao parsear validação LLM: {e}")
+            return {
+                'valid': False,
+                'score': 0,
+                'reason': f'Erro ao parsear resposta: {e}',
+                'method': 'llm',
+                'raw_response': llm_response
+            }
+    
+    def _validate_with_keyword(self, response: str, expected_content: str) -> Dict[str, Any]:
+        """
+        Valida usando palavras-chave
+        
+        Args:
+            response: Resposta para validar
+            expected_content: Conteúdo esperado
+            
+        Returns:
+            Resultado da validação
+        """
+        if not expected_content:
+            return {
+                'valid': False,
+                'score': 0,
+                'reason': 'Conteúdo esperado não fornecido',
+                'method': 'keyword'
+            }
+        
+        try:
+            # Normaliza textos
+            response_normalized = response.lower().strip()
+            expected_normalized = expected_content.lower().strip()
+            
+            # Verifica se contém o conteúdo esperado
+            contains_expected = expected_normalized in response_normalized
+            
+            # Calcula score baseado na presença
+            score = 100 if contains_expected else 0
+            
+            # Verifica se há erro explícito
+            error_keywords = ['erro', 'error', 'falha', 'exception', 'não foi possível']
+            has_error = any(keyword in response_normalized for keyword in error_keywords)
+            
+            if has_error:
+                score = max(0, score - 50)  # Penaliza erros
+            
+            return {
+                'valid': contains_expected and not has_error,
+                'score': score,
+                'reason': f'Conteúdo {"encontrado" if contains_expected else "não encontrado"}. {"Erro detectado" if has_error else "Sem erros"}',
+                'method': 'keyword',
+                'expected_content': expected_content,
+                'contains_expected': contains_expected,
+                'has_error': has_error
+            }
+            
+        except Exception as e:
+            logging.error(f"Erro na validação por keyword: {e}")
+            return {
+                'valid': False,
+                'score': 0,
+                'reason': f'Erro na validação: {e}',
+                'method': 'keyword'
+            }
+    
+    def validate_sql_syntax(self, sql_query: str) -> Dict[str, Any]:
+        """
+        Valida sintaxe SQL básica
+        
+        Args:
+            sql_query: Query SQL para validar
+            
+        Returns:
+            Resultado da validação de sintaxe
+        """
+        try:
+            if not sql_query or not sql_query.strip():
+                return {
+                    'valid': False,
+                    'reason': 'Query SQL vazia'
+                }
+            
+            sql_normalized = sql_query.strip().upper()
+            
+            # Verificações básicas
+            checks = {
+                'has_select': 'SELECT' in sql_normalized,
+                'has_from': 'FROM' in sql_normalized,
+                'balanced_parentheses': sql_query.count('(') == sql_query.count(')'),
+                'no_obvious_errors': not any(error in sql_normalized for error in ['ERROR', 'SYNTAX ERROR', 'INVALID'])
+            }
+            
+            all_valid = all(checks.values())
+            
+            return {
+                'valid': all_valid,
+                'checks': checks,
+                'reason': 'Sintaxe SQL válida' if all_valid else 'Problemas de sintaxe detectados'
+            }
+            
+        except Exception as e:
+            return {
+                'valid': False,
+                'reason': f'Erro na validação de sintaxe: {e}'
+            }
+    
+    async def batch_validate(self, results: list, method: str = 'llm', expected_content: str = None) -> list:
+        """
+        Valida múltiplos resultados em lote
+        
+        Args:
+            results: Lista de resultados para validar
+            method: Método de validação
+            expected_content: Conteúdo esperado
+            
+        Returns:
+            Lista de validações
+        """
+        tasks = []
+        
+        for result in results:
+            task = self.validate_result(
+                question=result.get('question', ''),
+                sql_query=result.get('sql_query', ''),
+                response=result.get('response', ''),
+                method=method,
+                expected_content=expected_content
+            )
+            tasks.append(task)
+        
+        return await asyncio.gather(*tasks, return_exceptions=True)

utils/config.py

@@ -12,6 +12,7 @@ load_dotenv()
 HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
 
 # Configurações do LangSmith (observabilidade)
 LANGSMITH_API_KEY = os.getenv("LANGSMITH_API_KEY")
@@ -30,7 +31,9 @@ AVAILABLE_MODELS = {
     "GPT-o3-mini": "o3-mini",
     "GPT-4o-mini": "gpt-4o-mini",
     "GPT-4o": "gpt-4o",
-    "Claude-3.5-Sonnet": "claude-3-5-sonnet-20241022"
+    "Claude-3.5-Sonnet": "claude-3-5-sonnet-20241022",
+    "Gemini-1.5-Pro": "gemini-1.5-pro",
+    "Gemini-2.0-Flash": "gemini-2.0-flash"
 }
 
 # Modelos para refinamento (apenas uso interno)
@@ -52,7 +55,9 @@ MAX_TOKENS_MAP = {
     "o3-mini": 4096,
     "gpt-4o-mini": 4096,
     "gpt-4o": 4096,
-    "claude-3-5-sonnet-20241022": 1024
+    "claude-3-5-sonnet-20241022": 1024,
+    "gemini-1.5-pro": 4096,
+    "gemini-2.0-flash": 4096
 }
 
 # Modelos que usam OpenAI (GPT)
@@ -67,6 +72,12 @@ ANTHROPIC_MODELS = {
     "claude-3-5-sonnet-20241022"
 }
 
+# Modelos que usam Google (Gemini)
+GOOGLE_MODELS = {
+    "gemini-1.5-pro",
+    "gemini-2.0-flash"
+}
+
 # Modelos que usam HuggingFace (para refinamento)
 HUGGINGFACE_MODELS = {
     "meta-llama/Llama-3.3-70B-Instruct",
@@ -99,6 +110,10 @@ os.makedirs(UPLOAD_DIR, exist_ok=True)
 if OPENAI_API_KEY:
     os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
 
+# Configuração das variáveis de ambiente para Google
+if GOOGLE_API_KEY:
+    os.environ["GOOGLE_API_KEY"] = GOOGLE_API_KEY
+
 # Configuração das variáveis de ambiente para Anthropic
 if ANTHROPIC_API_KEY:
     os.environ["ANTHROPIC_API_KEY"] = ANTHROPIC_API_KEY

utils/database.py

@@ -88,6 +88,3 @@ def validate_database(engine) -> bool:
         logging.error(f"Erro na validação do banco: {e}")
         return False
 
-# FUNÇÃO REMOVIDA: async_create_engine_and_load_db
-# Esta função foi removida junto com create_engine_and_load_db
-# Use a nova arquitetura de nós: csv_processing_node.py + database_node.py

utils/object_manager.py

@@ -19,6 +19,8 @@ class ObjectManager:
         self._cache_managers: Dict[str, Any] = {}
         # Mapeamento para relacionar agentes com seus bancos
         self._agent_db_mapping: Dict[str, str] = {}
+        # Metadados de conexões (CSV/PostgreSQL)
+        self._connection_metadata: Dict[str, Dict[str, Any]] = {}
     
     def store_sql_agent(self, agent: Any, db_id: str = None) -> str:
         """Armazena agente SQL e retorna ID"""
@@ -128,8 +130,45 @@ class ObjectManager:
         self._databases.clear()
         self._cache_managers.clear()
         self._agent_db_mapping.clear()
+        self._connection_metadata.clear()
         logging.info("Todos os objetos foram limpos do gerenciador")
-    
+
+    def store_connection_metadata(self, connection_id: str, metadata: Dict[str, Any]) -> str:
+        """
+        Armazena metadados de conexão
+
+        Args:
+            connection_id: ID da conexão
+            metadata: Metadados da conexão
+
+        Returns:
+            ID dos metadados armazenados
+        """
+        self._connection_metadata[connection_id] = metadata
+        logging.info(f"Metadados de conexão armazenados com ID: {connection_id}")
+        return connection_id
+
+    def get_connection_metadata(self, connection_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Recupera metadados de conexão pelo ID
+
+        Args:
+            connection_id: ID da conexão
+
+        Returns:
+            Metadados da conexão ou None se não encontrado
+        """
+        return self._connection_metadata.get(connection_id)
+
+    def get_all_connection_metadata(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Retorna todos os metadados de conexão
+
+        Returns:
+            Dicionário com todos os metadados
+        """
+        return self._connection_metadata.copy()
+
     def get_stats(self) -> Dict[str, int]:
         """Retorna estatísticas dos objetos armazenados"""
         return {
@@ -138,7 +177,8 @@ class ObjectManager:
             "databases": len(self._databases),
             "cache_managers": len(self._cache_managers),
             "general_objects": len(self._objects),
-            "agent_db_mappings": len(self._agent_db_mapping)
+            "agent_db_mappings": len(self._agent_db_mapping),
+            "connection_metadata": len(self._connection_metadata)
         }
 
 # Instância global do gerenciador

utils/validation.py

@@ -0,0 +1,299 @@
+"""
+Utilitários de validação para o sistema AgentGraph
+"""
+import re
+import logging
+from typing import Dict, Any, Tuple, Optional
+
+
+def validate_postgresql_config(config: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
+    """
+    Valida configuração postgresql completa
+    
+    Args:
+        config: Dicionário com configuração postgresql
+        
+    Returns:
+        Tupla (válido, mensagem_erro)
+    """
+    try:
+        # Campos obrigatórios
+        required_fields = ["host", "port", "database", "username", "password"]
+        
+        for field in required_fields:
+            if field not in config or not config[field]:
+                return False, f"Campo obrigatório ausente ou vazio: {field}"
+        
+        # Validação específica do host
+        host = str(config["host"]).strip()
+        if not host:
+            return False, "Host não pode estar vazio"
+        
+        # Validação básica de formato de host
+        if not _is_valid_host(host):
+            return False, "Formato de host inválido"
+        
+        # Validação da porta
+        try:
+            port = int(config["port"])
+            if port < 1 or port > 65535:
+                return False, "Porta deve estar entre 1 e 65535"
+        except (ValueError, TypeError):
+            return False, "Porta deve ser um número válido"
+        
+        # Validação do nome do banco
+        database = str(config["database"]).strip()
+        if not database:
+            return False, "Nome do banco não pode estar vazio"
+        
+        if not _is_valid_database_name(database):
+            return False, "Nome do banco contém caracteres inválidos"
+        
+        # Validação do usuário
+        username = str(config["username"]).strip()
+        if not username:
+            return False, "Nome de usuário não pode estar vazio"
+        
+        if not _is_valid_username(username):
+            return False, "Nome de usuário contém caracteres inválidos"
+        
+        # Validação da senha (básica)
+        password = str(config["password"])
+        if not password:
+            return False, "Senha não pode estar vazia"
+        
+        return True, None
+        
+    except Exception as e:
+        return False, f"Erro na validação: {e}"
+
+
+def _is_valid_host(host: str) -> bool:
+    """
+    Valida formato de host (IP ou hostname)
+    
+    Args:
+        host: Host a validar
+        
+    Returns:
+        True se válido
+    """
+    # Regex para IPv4
+    ipv4_pattern = r'^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$'
+    
+    # Regex para hostname/FQDN
+    hostname_pattern = r'^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$'
+    
+    # Permite localhost
+    if host.lower() == 'localhost':
+        return True
+    
+    # Valida IPv4
+    if re.match(ipv4_pattern, host):
+        return True
+    
+    # Valida hostname
+    if re.match(hostname_pattern, host):
+        return True
+    
+    return False
+
+
+def _is_valid_database_name(database: str) -> bool:
+    """
+    Valida nome de banco postgresql
+    
+    Args:
+        database: Nome do banco
+        
+    Returns:
+        True se válido
+    """
+    # postgresql: deve começar com letra ou underscore, 
+    # pode conter letras, números, underscores e hífens
+    pattern = r'^[a-zA-Z_][a-zA-Z0-9_-]*$'
+    
+    # Comprimento máximo típico
+    if len(database) > 63:
+        return False
+    
+    return bool(re.match(pattern, database))
+
+
+def _is_valid_username(username: str) -> bool:
+    """
+    Valida nome de usuário postgresql
+    
+    Args:
+        username: Nome de usuário
+        
+    Returns:
+        True se válido
+    """
+    # Similar ao nome do banco
+    pattern = r'^[a-zA-Z_][a-zA-Z0-9_-]*$'
+    
+    # Comprimento máximo típico
+    if len(username) > 63:
+        return False
+    
+    return bool(re.match(pattern, username))
+
+
+def validate_csv_file_path(file_path: str) -> Tuple[bool, Optional[str]]:
+    """
+    Valida caminho de arquivo csv
+    
+    Args:
+        file_path: Caminho do arquivo
+        
+    Returns:
+        Tupla (válido, mensagem_erro)
+    """
+    try:
+        import os
+        
+        if not file_path:
+            return False, "Caminho do arquivo não pode estar vazio"
+        
+        if not os.path.exists(file_path):
+            return False, f"Arquivo não encontrado: {file_path}"
+        
+        if not file_path.lower().endswith('.csv'):
+            return False, "Arquivo deve ter extensão .csv"
+        
+        # Verifica se é um arquivo (não diretório)
+        if not os.path.isfile(file_path):
+            return False, "Caminho deve apontar para um arquivo"
+        
+        # Verifica tamanho do arquivo
+        file_size = os.path.getsize(file_path)
+        if file_size == 0:
+            return False, "Arquivo csv está vazio"
+        
+        # Limite de 5GB
+        if file_size > 5 * 1024 * 1024 * 1024:
+            return False, "Arquivo muito grande (máximo 5GB)"
+        
+        return True, None
+        
+    except Exception as e:
+        return False, f"Erro na validação do arquivo: {e}"
+
+
+def validate_connection_state(state: Dict[str, Any]) -> Tuple[bool, Optional[str]]:
+    """
+    Valida estado de conexão completo
+    
+    Args:
+        state: Estado da conexão
+        
+    Returns:
+        Tupla (válido, mensagem_erro)
+    """
+    try:
+        connection_type = state.get("connection_type", "csv")
+        
+        if connection_type.lower() not in ["csv", "postgresql"]:
+            return False, f"Tipo de conexão inválido: {connection_type}"
+
+        if connection_type.lower() == "postgresql":
+            postgresql_config = state.get("postgresql_config")
+            if not postgresql_config:
+                return False, "Configuração postgresql ausente"
+
+            return validate_postgresql_config(postgresql_config)
+
+        elif connection_type.lower() == "csv":
+            file_path = state.get("file_path")
+            if file_path:
+                return validate_csv_file_path(file_path)
+            else:
+                # Verifica se há banco existente
+                import os
+                from utils.config import SQL_DB_PATH
+                
+                if not os.path.exists(SQL_DB_PATH):
+                    return False, "Nenhum arquivo csv fornecido e nenhum banco existente"
+                
+                return True, None
+        
+        return True, None
+        
+    except Exception as e:
+        return False, f"Erro na validação do estado: {e}"
+
+
+def sanitize_postgresql_config(config: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Sanitiza configuração postgresql removendo espaços e normalizando
+    
+    Args:
+        config: Configuração original
+        
+    Returns:
+        Configuração sanitizada
+    """
+    try:
+        sanitized = {}
+        
+        # Host
+        sanitized["host"] = str(config.get("host", "")).strip()
+        
+        # Porta
+        try:
+            sanitized["port"] = int(config.get("port", 5432))
+        except (ValueError, TypeError):
+            sanitized["port"] = 5432
+        
+        # Database
+        sanitized["database"] = str(config.get("database", "")).strip()
+        
+        # Username
+        sanitized["username"] = str(config.get("username", "")).strip()
+        
+        # Password (não remove espaços - pode ser intencional)
+        sanitized["password"] = str(config.get("password", ""))
+        
+        return sanitized
+        
+    except Exception as e:
+        logging.error(f"Erro ao sanitizar configuração postgresql: {e}")
+        return config
+
+
+def get_connection_error_message(error: Exception) -> str:
+    """
+    Converte erro de conexão em mensagem amigável
+    
+    Args:
+        error: Exceção capturada
+        
+    Returns:
+        Mensagem de erro amigável
+    """
+    error_str = str(error).lower()
+    
+    if "password authentication failed" in error_str:
+        return "❌ Falha na autenticação: Usuário ou senha incorretos"
+    
+    elif "could not connect to server" in error_str:
+        return "❌ Não foi possível conectar ao servidor: Verifique host e porta"
+    
+    elif "database" in error_str and "does not exist" in error_str:
+        return "❌ Banco de dados não existe: Verifique o nome do banco"
+    
+    elif "connection refused" in error_str:
+        return "❌ Conexão recusada: Servidor postgresql pode estar desligado"
+    
+    elif "timeout" in error_str:
+        return "❌ Timeout na conexão: Servidor demorou muito para responder"
+    
+    elif "permission denied" in error_str:
+        return "❌ Permissão negada: Usuário não tem acesso ao banco"
+    
+    elif "too many connections" in error_str:
+        return "❌ Muitas conexões: Servidor postgresql está sobrecarregado"
+    
+    else:
+        return f"❌ Erro de conexão: {str(error)}"