Delete agents

agents/sql_agent.py

@@ -1,392 +0,0 @@
-"""
-Criação e configuração do agente SQL
-"""
-import logging
-import time
-import asyncio
-from typing import Optional, Dict, Any, List
-from langchain_openai import ChatOpenAI
-from langchain_anthropic import ChatAnthropic
-from langchain_community.agent_toolkits import create_sql_agent
-from langchain_community.utilities import SQLDatabase
-from langchain.callbacks.base import BaseCallbackHandler
-from langchain.schema import AgentAction, AgentFinish
-
-
-from utils.config import (
-    MAX_ITERATIONS,
-    TEMPERATURE,
-    AVAILABLE_MODELS,
-    OPENAI_MODELS,
-    ANTHROPIC_MODELS
-)
-
-class SQLQueryCaptureHandler(BaseCallbackHandler):
-    """
-    Handler para capturar queries SQL executadas pelo agente
-    """
-
-    def __init__(self):
-        super().__init__()
-        self.sql_queries: List[str] = []
-        self.agent_actions: List[Dict[str, Any]] = []
-        self.step_count = 0
-
-    def on_agent_action(self, action: AgentAction, **kwargs) -> None:
-        """
-        Captura ações do agente, especialmente queries SQL
-
-        Args:
-            action: Ação do agente
-        """
-        try:
-            self.step_count += 1
-            tool_name = action.tool
-            tool_input = action.tool_input
-
-            # Capturar SQL especificamente (sem log de cada passo)
-            if tool_name == 'sql_db_query' and isinstance(tool_input, dict):
-                sql_query = tool_input.get('query', '')
-                if sql_query and sql_query.strip():
-                    clean_query = sql_query.strip()
-                    self.sql_queries.append(clean_query)
-
-                    # Log apenas uma vez com query completa
-                    logging.info(f"[SQL_HANDLER] 🔍 Query SQL capturada:\n{clean_query}")
-
-            # Armazenar todas as ações para debug
-            self.agent_actions.append({
-                "step": self.step_count,
-                "tool": tool_name,
-                "input": tool_input,
-                "timestamp": time.time()
-            })
-
-        except Exception as e:
-            logging.error(f"[SQL_HANDLER] Erro ao capturar ação: {e}")
-
-    def get_last_sql_query(self) -> Optional[str]:
-        """
-        Retorna a última query SQL capturada
-
-        Returns:
-            Última query SQL ou None se não houver
-        """
-        return self.sql_queries[-1] if self.sql_queries else None
-
-    def get_all_sql_queries(self) -> List[str]:
-        """
-        Retorna todas as queries SQL capturadas
-
-        Returns:
-            Lista de queries SQL
-        """
-        return self.sql_queries.copy()
-
-    def reset(self):
-        """Reseta o handler para nova execução"""
-        self.sql_queries.clear()
-        self.agent_actions.clear()
-        self.step_count = 0
-
-async def retry_with_backoff(func, max_retries=3, base_delay=1.0):
-    """
-    Executa função com retry e backoff exponencial para lidar com rate limiting
-
-    Args:
-        func: Função a ser executada
-        max_retries: Número máximo de tentativas
-        base_delay: Delay base em segundos
-
-    Returns:
-        Resultado da função ou levanta exceção após esgotar tentativas
-    """
-    for attempt in range(max_retries + 1):
-        try:
-            return func()
-        except Exception as e:
-            error_str = str(e)
-
-            # Verifica se é erro de rate limiting ou overload
-            if any(keyword in error_str.lower() for keyword in ['overloaded', 'rate_limit', 'too_many_requests', 'quota']):
-                if attempt < max_retries:
-                    delay = base_delay * (2 ** attempt)  # Backoff exponencial
-                    logging.warning(f"API sobrecarregada (tentativa {attempt + 1}/{max_retries + 1}). Aguardando {delay}s...")
-                    await asyncio.sleep(delay)
-                    continue
-                else:
-                    logging.error(f"API continua sobrecarregada após {max_retries + 1} tentativas")
-                    raise Exception(f"API da Anthropic sobrecarregada. Tente novamente em alguns minutos. Erro original: {e}")
-            else:
-                # Se não é erro de rate limiting, levanta imediatamente
-                raise e
-
-    # Não deveria chegar aqui, mas por segurança
-    raise Exception("Número máximo de tentativas excedido")
-
-
-
-def create_sql_agent_executor(db: SQLDatabase, model_name: str = "gpt-4o-mini"):
-    """
-    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)
-
-    Returns:
-        Agente SQL configurado
-    """
-    try:
-        # Obtém o ID real do modelo
-        model_id = AVAILABLE_MODELS.get(model_name, model_name)
-
-        # Cria o modelo LLM baseado no provedor
-        if model_id in OPENAI_MODELS:
-            # Configurações específicas para modelos OpenAI
-            if model_id == "o3-mini":
-                # o3-mini não suporta temperature
-                llm = ChatOpenAI(model=model_id)
-            else:
-                # GPT-4o e GPT-4o-mini suportam temperature
-                llm = ChatOpenAI(model=model_id, temperature=TEMPERATURE)
-
-            agent_type = "openai-tools"
-
-        elif model_id in ANTHROPIC_MODELS:
-            # Claude com tool-calling e configurações para rate limiting
-            llm = ChatAnthropic(
-                model=model_id,
-                temperature=TEMPERATURE,
-                max_tokens=4096,
-                max_retries=2,  # Retry interno do cliente
-                timeout=60.0    # Timeout mais longo
-            )
-            agent_type = "tool-calling"  # Claude usa tool-calling
-
-        else:
-            # Fallback para OpenAI
-            llm = ChatOpenAI(
-                model="gpt-4o-mini",
-                temperature=TEMPERATURE
-            )
-            agent_type = "openai-tools"
-            logging.warning(f"Modelo {model_name} não reconhecido, usando gpt-4o-mini como fallback")
-
-        # Cria o agente SQL
-        sql_agent = create_sql_agent(
-            llm=llm,
-            db=db,
-            agent_type=agent_type,
-            verbose=True,
-            max_iterations=MAX_ITERATIONS,
-            return_intermediate_steps=True,
-            top_k=10
-        )
-
-        logging.info(f"Agente SQL criado com sucesso usando modelo {model_name} ({model_id}) com agent_type={agent_type}")
-        return sql_agent
-
-    except Exception as e:
-        logging.error(f"Erro ao criar agente SQL: {e}")
-        raise
-
-class SQLAgentManager:
-    """
-    Gerenciador do agente SQL com funcionalidades avançadas
-    """
-    
-    def __init__(self, db: SQLDatabase, model_name: str = "gpt-4o-mini"):
-        self.db = db
-        self.model_name = model_name
-        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)
-    
-    def recreate_agent(self, new_db: SQLDatabase = None, new_model: str = None):
-        """
-        Recria o agente com novos parâmetros
-        
-        Args:
-            new_db: Novo banco de dados (opcional)
-            new_model: Novo modelo (opcional)
-        """
-        if new_db:
-            self.db = new_db
-        if new_model:
-            self.model_name = new_model
-        
-        self._initialize_agent()
-        logging.info("Agente SQL recriado com sucesso")
-    
-    def _extract_text_from_claude_response(self, output) -> str:
-        """
-        Extrai texto limpo da resposta do Claude que pode vir em formato complexo
-
-        Args:
-            output: Resposta do agente (pode ser string, lista ou dict)
-
-        Returns:
-            String limpa com o texto da resposta
-        """
-        try:
-            # Se já é string, retorna diretamente
-            if isinstance(output, str):
-                return output
-
-            # Se é lista, procura por dicionários com 'text'
-            if isinstance(output, list):
-                text_parts = []
-                for item in output:
-                    if isinstance(item, dict) and 'text' in item:
-                        text_parts.append(item['text'])
-                    elif isinstance(item, str):
-                        text_parts.append(item)
-
-                if text_parts:
-                    return '\n'.join(text_parts)
-
-            # Se é dict, procura por 'text' ou converte para string
-            if isinstance(output, dict):
-                if 'text' in output:
-                    return output['text']
-                elif 'content' in output:
-                    return str(output['content'])
-
-            # Fallback: converte para string
-            return str(output)
-
-        except Exception as e:
-            logging.warning(f"Erro ao extrair texto da resposta: {e}")
-            return str(output)
-
-    async def execute_query(self, instruction: str) -> dict:
-        """
-        Executa uma query através do agente SQL com retry para rate limiting
-
-        Args:
-            instruction: Instrução para o agente
-
-        Returns:
-            Resultado da execução
-        """
-        try:
-            logging.info("------- Agent SQL: Executando query -------")
-
-            # Criar handler para capturar SQL
-            sql_handler = SQLQueryCaptureHandler()
-
-            # Verifica se é agente Claude para aplicar retry
-            model_id = getattr(self, 'model_name', '')
-            is_claude = any(claude_model in model_id for claude_model in ANTHROPIC_MODELS)
-
-            if is_claude:
-                # Usa retry com backoff para Claude
-                response = await retry_with_backoff(
-                    lambda: self.agent.invoke(
-                        {"input": instruction},
-                        {"callbacks": [sql_handler]}
-                    ),
-                    max_retries=3,
-                    base_delay=2.0
-                )
-            else:
-                # Execução normal para outros modelos
-                response = self.agent.invoke(
-                    {"input": instruction},
-                    {"callbacks": [sql_handler]}
-                )
-
-            # Extrai e limpa a resposta
-            raw_output = response.get("output", "Erro ao obter a resposta do agente.")
-            clean_output = self._extract_text_from_claude_response(raw_output)
-
-            # Captura a última query SQL executada
-            sql_query = sql_handler.get_last_sql_query()
-
-            result = {
-                "output": clean_output,
-                "intermediate_steps": response.get("intermediate_steps", []),
-                "success": True,
-                "sql_query": sql_query,  # ← Query SQL capturada
-                "all_sql_queries": sql_handler.get_all_sql_queries()
-            }
-
-            logging.info(f"Query executada com sucesso: {result['output'][:100]}...")
-            return result
-
-        except Exception as e:
-            error_str = str(e)
-
-            # Mensagem mais amigável para problemas de rate limiting
-            if any(keyword in error_str.lower() for keyword in ['overloaded', 'rate_limit', 'too_many_requests', 'quota']):
-                error_msg = (
-                    "🚫 **API da Anthropic temporariamente sobrecarregada**\n\n"
-                    "A API do Claude está com muitas solicitações no momento. "
-                    "Por favor, aguarde alguns minutos e tente novamente.\n\n"
-                    "**Sugestões:**\n"
-                    "- Aguarde 2-3 minutos antes de tentar novamente\n"
-                    "- Considere usar um modelo OpenAI temporariamente\n"
-                    "- Tente novamente em horários de menor movimento\n\n"
-                    f"*Erro técnico: {e}*"
-                )
-            else:
-                error_msg = f"Erro ao consultar o agente SQL: {e}"
-
-            logging.error(error_msg)
-            return {
-                "output": error_msg,
-                "intermediate_steps": [],
-                "success": False
-            }
-    
-    def get_agent_info(self) -> dict:
-        """
-        Retorna informações sobre o agente atual
-        
-        Returns:
-            Dicionário com informações do agente
-        """
-        return {
-            "model_name": self.model_name,
-            "max_iterations": MAX_ITERATIONS,
-            "temperature": TEMPERATURE,
-            "database_tables": self.db.get_usable_table_names() if self.db else [],
-            "agent_type": "openai-tools"
-        }
-    
-    def validate_agent(self) -> bool:
-        """
-        Valida se o agente está funcionando corretamente
-        
-        Returns:
-            True se válido, False caso contrário
-        """
-        try:
-            # Testa com uma query simples
-            test_result = self.agent.invoke({
-                "input": "Quantas linhas existem na tabela?"
-            })
-            
-            success = "output" in test_result and test_result["output"]
-            logging.info(f"Validação do agente: {'Sucesso' if success else 'Falha'}")
-            return success
-            
-        except Exception as e:
-            logging.error(f"Erro na validação do agente: {e}")
-            return False
-
-def get_default_sql_agent(db: SQLDatabase) -> SQLAgentManager:
-    """
-    Cria um agente SQL com configurações padrão
-    
-    Args:
-        db: Objeto SQLDatabase
-        
-    Returns:
-        SQLAgentManager configurado
-    """
-    return SQLAgentManager(db)

agents/tools.py

@@ -1,432 +0,0 @@
-"""
-Ferramentas para o agente SQL
-"""
-import time
-import logging
-import re
-from typing import Dict, Any, Optional, List
-from huggingface_hub import InferenceClient
-from langchain_community.utilities import SQLDatabase
-from langchain_openai import ChatOpenAI
-from langchain_anthropic import ChatAnthropic
-import pandas as pd
-
-from utils.config import (
-    HUGGINGFACE_API_KEY,
-    OPENAI_API_KEY,
-    ANTHROPIC_API_KEY,
-    AVAILABLE_MODELS,
-    REFINEMENT_MODELS,
-    LLAMA_MODELS,
-    MAX_TOKENS_MAP,
-    OPENAI_MODELS,
-    ANTHROPIC_MODELS,
-    HUGGINGFACE_MODELS
-)
-
-# Cliente HuggingFace
-hf_client = InferenceClient(
-    provider="together",
-    api_key=HUGGINGFACE_API_KEY
-)
-
-# Cliente OpenAI
-openai_client = None
-if OPENAI_API_KEY:
-    openai_client = ChatOpenAI(
-        api_key=OPENAI_API_KEY,
-        temperature=0
-    )
-
-# Cliente Anthropic
-anthropic_client = None
-if ANTHROPIC_API_KEY:
-    anthropic_client = ChatAnthropic(
-        model="claude-3-5-sonnet-20241022",
-        api_key=ANTHROPIC_API_KEY,
-        temperature=0
-    )
-
-def generate_initial_context(db_sample: pd.DataFrame) -> str:
-    """
-    Gera contexto inicial para o modelo LLM
-
-    Args:
-        db_sample: Amostra dos dados do banco
-
-    Returns:
-        String com o contexto formatado
-    """
-    return (
-        f"Você é um assistente especializado em gerar queries SQL precisas e otimizadas. Analise cuidadosamente a estrutura da tabela e a pergunta do usuário.\n\n"
-
-        "**REGRAS ESSENCIAIS**:\n"
-        "1. Nunca altere o idioma de nomes ou palavras na pergunta do usuário.\n"
-        "2. Para buscar texto parcial use LIKE '%termo%'.\n"
-        "3. Para NULL use IS NULL ou IS NOT NULL (nunca = NULL).\n"
-        "4. Em agregações (SUM, COUNT, AVG) use GROUP BY nas colunas não agregadas.\n"
-        "5. Para datas use formato 'YYYY-MM-DD' ou funções date() do SQLite.\n"
-        "6. Nomes de colunas devem ser EXATAMENTE como mostrado.\n"
-        "- Estamos usando o idioma Português do Brasil.\n"
-    )
-
-def is_greeting(user_query: str) -> bool:
-    """
-    Verifica se a query do usuário é uma saudação
-    
-    Args:
-        user_query: Query do usuário
-        
-    Returns:
-        True se for saudação, False caso contrário
-    """
-    greetings = ["olá", "oi", "bom dia", "boa tarde", "boa noite", "oi, tudo bem?"]
-    return user_query.lower().strip() in greetings
-
-def detect_query_type(user_query: str) -> str:
-    """
-    Detecta o tipo de processamento necessário para a query do usuário
-
-    Args:
-        user_query: Pergunta do usuário
-
-    Returns:
-        Tipo de processamento: 'sql_query', 'sql_query_graphic', 'prediction', 'chart'
-    """
-    query_lower = user_query.lower().strip()
-
-    # Palavras-chave para diferentes tipos
-    prediction_keywords = ['prever', 'predizer', 'previsão', 'forecast', 'predict', 'tendência', 'projeção']
-
-    # Palavras-chave para gráficos - expandida para melhor detecção
-    chart_keywords = [
-        'gráfico', 'grafico', 'chart', 'plot', 'visualizar', 'visualização', 'visualizacao',
-        'mostrar gráfico', 'mostrar grafico', 'gerar gráfico', 'gerar grafico',
-        'criar gráfico', 'criar grafico', 'plotar', 'desenhar gráfico', 'desenhar grafico',
-        'exibir gráfico', 'exibir grafico', 'fazer gráfico', 'fazer grafico',
-        'gráfico de', 'grafico de', 'em gráfico', 'em grafico',
-        'barras', 'linha', 'pizza', 'área', 'area', 'histograma',
-        'scatter', 'dispersão', 'dispersao', 'boxplot', 'heatmap'
-    ]
-
-    # Verifica se há solicitação de gráfico
-    has_chart_request = any(keyword in query_lower for keyword in chart_keywords)
-
-    # Verifica se há solicitação de previsão
-    has_prediction_request = any(keyword in query_lower for keyword in prediction_keywords)
-
-    # Lógica de detecção
-    if has_prediction_request:
-        return 'prediction'  # Futuro: agente de ML/previsões
-    elif has_chart_request:
-        return 'sql_query_graphic'  # SQL + Gráfico
-    else:
-        return 'sql_query'  # SQL normal
-
-def prepare_sql_context(user_query: str, db_sample: pd.DataFrame) -> str:
-    """
-    Prepara o contexto inicial para ser enviado diretamente ao agentSQL
-
-    Args:
-        user_query: Pergunta do usuário
-        db_sample: Amostra dos dados do banco
-
-    Returns:
-        Contexto formatado para o agentSQL
-    """
-    # Usa o contexto base do generate_initial_context
-    base_context = generate_initial_context(db_sample)
-
-    context = (
-        f"""
-        Você é um assistente especializado em consultas SQL e análise de dados.
-
-        REGRAS OBRIGATORIAS:
-        - “Retorne os resultados da consulta em formato legível, sem incluir o texto da query SQL.”
-        - “Estamos atulamente no ano de 2025.“
-        """
-        "\n\n"
-        f"**PERGUNTA DO USUÁRIO**:\n{user_query}"
-    )
-
-    return context
-
-async def refine_response_with_llm(
-    user_question: str, 
-    sql_response: str, 
-    chart_md: str = ""
-) -> str:
-    """
-    Refina a resposta usando um modelo LLM adicional
-    
-    Args:
-        user_question: Pergunta original do usuário
-        sql_response: Resposta do agente SQL
-        chart_md: Markdown de gráficos (opcional)
-        
-    Returns:
-        Resposta refinada
-    """
-    prompt = (
-        f"Pergunta do usuário:\n{user_question}\n\n"
-        f"Resposta gerada pelo agente SQL:\n{sql_response}\n\n"
-        "Sua tarefa é refinar a resposta para deixá-la mais clara, completa e compreensível em português, "
-        "mantendo a resposta original no início do texto e adicionando insights úteis sobre logística de entregas de produtos, "
-        "por exemplo: comparar com padrões típicos, identificar possíveis problemas ou sugerir ações para melhorar atrasos, performance ou custos. "
-        "Evite repetir informações sem necessidade e não invente dados."
-    )
-
-    logging.info(f"[DEBUG] Prompt enviado ao modelo de refinamento:\n{prompt}\n")
-
-    try:
-        response = hf_client.chat.completions.create(
-            model=REFINEMENT_MODELS["LLaMA 70B"],
-            messages=[{"role": "system", "content": prompt}],
-            max_tokens=1200,
-            stream=False
-        )
-        improved_response = response["choices"][0]["message"]["content"]
-        logging.info(f"[DEBUG] Resposta do modelo de refinamento:\n{improved_response}\n")
-        return improved_response + ("\n\n" + chart_md if chart_md else "")
-
-    except Exception as e:
-        logging.error(f"[ERRO] Falha ao refinar resposta com LLM: {e}")
-        return sql_response + ("\n\n" + chart_md if chart_md else "")
-
-class CacheManager:
-    """Gerenciador de cache para queries"""
-    
-    def __init__(self):
-        self.query_cache: Dict[str, str] = {}
-        self.history_log: List[Dict[str, Any]] = []
-        self.recent_history: List[Dict[str, str]] = []
-    
-    def get_cached_response(self, query: str) -> Optional[str]:
-        """Obtém resposta do cache"""
-        return self.query_cache.get(query)
-    
-    def cache_response(self, query: str, response: str):
-        """Armazena resposta no cache"""
-        self.query_cache[query] = response
-    
-    def add_to_history(self, entry: Dict[str, Any]):
-        """Adiciona entrada ao histórico"""
-        self.history_log.append(entry)
-    
-    def update_recent_history(self, user_input: str, response: str):
-        """Atualiza histórico recente"""
-        self.recent_history.append({"role": "user", "content": user_input})
-        self.recent_history.append({"role": "assistant", "content": response})
-        
-        # Mantém apenas as últimas 4 entradas (2 pares pergunta-resposta)
-        if len(self.recent_history) > 4:
-            self.recent_history.pop(0)
-            self.recent_history.pop(0)
-    
-    def clear_cache(self):
-        """Limpa todo o cache"""
-        self.query_cache.clear()
-        self.history_log.clear()
-        self.recent_history.clear()
-    
-    def get_history(self) -> List[Dict[str, Any]]:
-        """Retorna histórico completo"""
-        return self.history_log
-
-# ==================== FUNÇÕES DE GRÁFICOS ====================
-
-def generate_graph_type_context(user_query: str, sql_query: str, df_columns: List[str], df_sample: pd.DataFrame) -> str:
-    """
-    Gera contexto para LLM escolher o tipo de gráfico mais adequado
-
-    Args:
-        user_query: Pergunta original do usuário
-        sql_query: Query SQL gerada pelo agente
-        df_columns: Lista de colunas retornadas pela query
-        df_sample: Amostra dos dados para análise
-
-    Returns:
-        Contexto formatado para a LLM
-    """
-    # Criar uma descrição detalhada dos dados para ajudar a LLM a entender melhor a estrutura
-    data_description = ""
-    if not df_sample.empty:
-        # Verificar tipos de dados de forma mais robusta
-        numeric_cols = []
-        date_cols = []
-        categorical_cols = []
-
-        for col in df_sample.columns:
-            col_data = df_sample[col]
-
-            # Verifica se é numérico (incluindo strings que representam números)
-            try:
-                # Tenta converter para numérico, tratando vírgulas como separador decimal
-                if col_data.dtype == 'object':
-                    test_numeric = pd.to_numeric(col_data.astype(str).str.replace(',', '.'), errors='coerce')
-                    if test_numeric.notna().sum() > len(col_data) * 0.8:  # 80% são números válidos
-                        numeric_cols.append(col)
-                    else:
-                        categorical_cols.append(col)
-                elif pd.api.types.is_numeric_dtype(col_data):
-                    numeric_cols.append(col)
-                elif pd.api.types.is_datetime64_any_dtype(col_data) or 'data' in col.lower():
-                    date_cols.append(col)
-                else:
-                    categorical_cols.append(col)
-            except:
-                categorical_cols.append(col)
-
-        # Adicionar informações sobre os primeiros valores de cada coluna
-        data_description = "\nAmostra dos dados (primeiras 3 linhas):\n"
-        data_description += df_sample.head(3).to_string(index=False)
-
-        # Adicionar análise detalhada dos tipos de dados
-        data_description += f"\n\nAnálise dos dados ({len(df_sample)} linhas total):"
-        data_description += f"\n- Total de colunas: {len(df_sample.columns)}"
-
-        if numeric_cols:
-            data_description += f"\n- Colunas NUMÉRICAS ({len(numeric_cols)}): {', '.join(numeric_cols)}"
-            # Adiciona informação sobre valores numéricos
-            for col in numeric_cols[:2]:  # Máximo 2 colunas para não ficar muito longo
-                try:
-                    if df_sample[col].dtype == 'object':
-                        # Converte strings para números
-                        numeric_values = pd.to_numeric(df_sample[col].astype(str).str.replace(',', '.'), errors='coerce')
-                        min_val, max_val = numeric_values.min(), numeric_values.max()
-                    else:
-                        min_val, max_val = df_sample[col].min(), df_sample[col].max()
-                    data_description += f"\n  • {col}: valores de {min_val} a {max_val}"
-                except:
-                    pass
-
-        if date_cols:
-            data_description += f"\n- Colunas de DATA/TEMPO ({len(date_cols)}): {', '.join(date_cols)}"
-
-        if categorical_cols:
-            data_description += f"\n- Colunas CATEGÓRICAS ({len(categorical_cols)}): {', '.join(categorical_cols)}"
-            # Adiciona informação sobre categorias únicas
-            for col in categorical_cols[:3]:  # Máximo 3 colunas
-                unique_count = df_sample[col].nunique()
-                data_description += f"\n  • {col}: {unique_count} valores únicos"
-
-            # Destaque especial para múltiplas categóricas importantes
-            if len(categorical_cols) >= 2 and len(numeric_cols) >= 1:
-                data_description += f"\n\n⚠️ ATENÇÃO: {len(categorical_cols)} colunas categóricas + {len(numeric_cols)} numérica(s) → CONSIDERE GRÁFICO AGRUPADO (6) para mostrar múltiplas dimensões!"
-
-    # Prompt ULTRA SIMPLIFICADO
-    return (
-        f"Escolha o gráfico mais adequado e de acordo com pergunta do usuário e os dados:\n\n"
-        f"COLUNAS RETORNADAS: {', '.join(df_columns)}\n\n"
-        f"DADOS: {data_description}\n\n"
-        f"PERGUNTA: {user_query}\n\n"
-        f"OPÇÕES DE GRÁFICOS::\n"
-        f"1. Linha - evolução temporal\n"
-        f"2. Multilinhas - múltiplas tendências\n"
-        f"3. Área - volume temporal\n"
-        f"4. Barras Verticais - comparar categorias (nomes curtos)\n"
-        f"5. Barras Horizontais - comparar categorias (nomes longos)\n"
-        f"6. Barras Agrupadas - múltiplas métricas\n"
-        f"7. Barras Empilhadas - partes de um todo\n"
-        f"8. Pizza - proporções (poucas categorias)\n"
-        f"9. Dona - proporções (muitas categorias)\n"
-        f"10. Pizzas Múltiplas - proporções por grupos\n\n"
-        f"Responda apenas o número (1-10)."
-        "\n\nINSTRUÇÕES FINAIS:\n"
-        "1. PRIMEIRO: Verifique se o usuário especificou um tipo de gráfico na pergunta do usuário\n"
-        "2. SE SIM: Use o gráfico solicitado (consulte o mapeamento acima)\n"
-        "3. SE NÃO: Escolha o gráfico mais adequado\n\n"
-    )
-
-def extract_sql_query_from_response(agent_response: str) -> Optional[str]:
-    """
-    Extrai a query SQL da resposta do agente SQL
-
-    Args:
-        agent_response: Resposta completa do agente SQL
-
-    Returns:
-        Query SQL extraída ou None se não encontrada
-    """
-    if not agent_response:
-        return None
-
-    # Padrões para encontrar SQL na resposta - ordem de prioridade
-    sql_patterns = [
-        # Padrão mais comum: ```sql ... ``` (multiline)
-        r"```sql\s*(.*?)\s*```",
-        # Padrão alternativo: ``` ... ``` com SELECT (multiline)
-        r"```\s*(SELECT.*?)\s*```",
-        # SELECT com múltiplas linhas até ponto e vírgula
-        r"(SELECT\s+.*?;)",
-        # SELECT com múltiplas linhas até quebra dupla ou final
-        r"(SELECT\s+.*?)(?:\n\s*\n|\n\s*$|\n\s*Agora|\n\s*Em seguida)",
-        # Padrões com prefixos específicos
-        r"Query:\s*(SELECT.*?)(?:\n|$|;)",
-        r"SQL:\s*(SELECT.*?)(?:\n|$|;)",
-        r"Consulta:\s*(SELECT.*?)(?:\n|$|;)",
-        # SELECT em uma linha
-        r"(SELECT\s+[^\n]+)",
-    ]
-
-    for i, pattern in enumerate(sql_patterns):
-        matches = re.findall(pattern, agent_response, re.DOTALL | re.IGNORECASE)
-        if matches:
-            # Pega a primeira query encontrada
-            query = matches[0].strip()
-
-            # Limpa a query
-            query = clean_sql_query(query)
-
-            # Verifica se é uma query válida
-            if is_valid_sql_query(query):
-                logging.info(f"[GRAPH] Query SQL extraída (padrão {i+1}): {query[:100]}...")
-                return query
-
-    # Log da resposta para debug se não encontrar SQL
-    logging.warning(f"[GRAPH] Não foi possível extrair query SQL. Resposta (primeiros 200 chars): {agent_response[:200]}...")
-    return None
-
-def clean_sql_query(query: str) -> str:
-    """
-    Limpa e normaliza a query SQL extraída
-
-    Args:
-        query: Query SQL bruta
-
-    Returns:
-        Query SQL limpa
-    """
-    if not query:
-        return ""
-
-    # Remove espaços extras e quebras de linha desnecessárias
-    query = re.sub(r'\s+', ' ', query.strip())
-
-    # Remove ponto e vírgula no final se existir
-    if query.endswith(';'):
-        query = query[:-1].strip()
-
-    # Remove aspas ou caracteres especiais no início/fim
-    query = query.strip('`"\'')
-
-    return query
-
-def is_valid_sql_query(query: str) -> bool:
-    """
-    Verifica se a string é uma query SQL válida
-
-    Args:
-        query: String para verificar
-
-    Returns:
-        True se for uma query SQL válida
-    """
-    if not query or len(query.strip()) < 6:  # Mínimo para "SELECT"
-        return False
-
-    # Verifica se começa com comando SQL válido
-    sql_commands = ['SELECT', 'INSERT', 'UPDATE', 'DELETE', 'WITH']
-    query_upper = query.strip().upper()
-
-    return any(query_upper.startswith(cmd) for cmd in sql_commands)