Deploy

.gitignore

@@ -0,0 +1,170 @@
+# Banco de dados
+data.db
+*.db
+*.sqlite
+*.sqlite3
+
+# Arquivos CSV de upload
+uploaded_data.csv
+test_upload.csv
+tabela.csv
+
+# Logs
+*.log
+logs/
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Distribuição / empacotamento
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# pipenv
+Pipfile.lock
+
+# PEP 582
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Temporary files
+*.tmp
+*.temp
+temp/
+tmp/
+
+# API Keys e configurações sensíveis
+.env.local
+.env.production
+config.json
+secrets.json
+
+# Gradio
+gradio_cached_examples/
+flagged/
+
+# Cache do sistema
+cache/
+*.cache

agents/processing_agent.py

@@ -0,0 +1,242 @@
+"""
+Agente de processamento de contexto inicial para sugestão de queries SQL
+"""
+import logging
+import asyncio
+from typing import Optional, Dict, Any
+from langchain_openai import ChatOpenAI
+from langchain_anthropic import ChatAnthropic
+from langchain_community.llms import HuggingFaceEndpoint
+from langchain.schema import HumanMessage
+
+from utils.config import (
+    TEMPERATURE,
+    AVAILABLE_MODELS,
+    OPENAI_MODELS,
+    ANTHROPIC_MODELS,
+    REFINEMENT_MODELS
+)
+
+
+class ProcessingAgentManager:
+    """
+    Gerenciador do agente de processamento de contexto inicial
+    """
+    
+    def __init__(self, model_name: str = "gpt-4o-mini"):
+        self.model_name = model_name
+        self.llm = None
+        self._initialize_llm()
+    
+    def _initialize_llm(self):
+        """Inicializa o modelo LLM baseado no nome fornecido"""
+        try:
+            # Obtém o ID real do modelo
+            model_id = AVAILABLE_MODELS.get(self.model_name, self.model_name)
+            
+            # Verifica se é modelo de refinamento
+            if model_id not in AVAILABLE_MODELS.values():
+                model_id = REFINEMENT_MODELS.get(self.model_name, model_id)
+            
+            # 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
+                    self.llm = ChatOpenAI(model=model_id)
+                else:
+                    # GPT-4o e GPT-4o-mini suportam temperature
+                    self.llm = ChatOpenAI(model=model_id, temperature=TEMPERATURE)
+                    
+            elif model_id in ANTHROPIC_MODELS:
+                # Claude com tool-calling e configurações para rate limiting
+                self.llm = ChatAnthropic(
+                    model=model_id,
+                    temperature=TEMPERATURE,
+                    max_tokens=4096,
+                    max_retries=2,
+                    timeout=60.0
+                )
+                
+            else:
+                # Modelos HuggingFace (refinement models)
+                self.llm = HuggingFaceEndpoint(
+                    endpoint_url=f"https://api-inference.huggingface.co/models/{model_id}",
+                    temperature=TEMPERATURE,
+                    max_new_tokens=1024,
+                    timeout=120
+                )
+                
+            logging.info(f"Processing Agent inicializado com modelo {model_id}")
+            
+        except Exception as e:
+            logging.error(f"Erro ao inicializar Processing Agent: {e}")
+            # Fallback para GPT-4o-mini
+            self.llm = ChatOpenAI(model="gpt-4o-mini", temperature=TEMPERATURE)
+            logging.warning("Usando GPT-4o-mini como fallback")
+    
+    def recreate_llm(self, new_model: str):
+        """
+        Recria o LLM com novo modelo
+
+        Args:
+            new_model: Nome do novo modelo
+        """
+        old_model = self.model_name
+        self.model_name = new_model
+        self._initialize_llm()
+        logging.info(f"[PROCESSING] Modelo alterado de '{old_model}' para '{new_model}'")
+    
+    async def process_context(self, context_prompt: str) -> Dict[str, Any]:
+        """
+        Processa o contexto inicial e retorna sugestão de query
+        
+        Args:
+            context_prompt: Prompt com contexto e pergunta do usuário
+            
+        Returns:
+            Resultado do processamento com pergunta e sugestão de query
+        """
+        try:
+            logging.info(f"[PROCESSING] ===== INICIANDO PROCESSING AGENT =====")
+            logging.info(f"[PROCESSING] Modelo utilizado: {self.model_name}")
+            logging.info(f"[PROCESSING] Tamanho do contexto: {len(context_prompt)} caracteres")
+
+            # Executa o processamento
+            if hasattr(self.llm, 'ainvoke'):
+                # Para modelos que suportam async
+                logging.info(f"[PROCESSING] Executando chamada assíncrona para {self.model_name}")
+                response = await self.llm.ainvoke([HumanMessage(content=context_prompt)])
+                output = response.content
+            else:
+                # Para modelos síncronos, executa em thread
+                logging.info(f"[PROCESSING] Executando chamada síncrona para {self.model_name}")
+                response = await asyncio.get_event_loop().run_in_executor(
+                    None,
+                    lambda: self.llm.invoke([HumanMessage(content=context_prompt)])
+                )
+                output = response.content if hasattr(response, 'content') else str(response)
+
+            logging.info(f"[PROCESSING] Resposta recebida do modelo ({len(output)} caracteres)")
+
+            # Processa a resposta
+            processed_result = self._parse_processing_response(output)
+
+            result = {
+                "success": True,
+                "output": output,
+                "processed_question": processed_result.get("question", ""),
+                "suggested_query": processed_result.get("query", ""),
+                "query_observations": processed_result.get("observations", ""),
+                "model_used": self.model_name
+            }
+
+            # Log simples do resultado
+            if result['suggested_query']:
+                logging.info(f"[PROCESSING] ✅ Query SQL extraída com sucesso")
+            else:
+                logging.warning(f"[PROCESSING] ❌ Nenhuma query SQL foi extraída")
+
+            logging.info(f"[PROCESSING] ===== PROCESSING AGENT CONCLUÍDO =====")
+            return result
+            
+        except Exception as e:
+            error_msg = f"Erro no Processing Agent: {e}"
+            logging.error(error_msg)
+            
+            return {
+                "success": False,
+                "output": error_msg,
+                "processed_question": "",
+                "suggested_query": "",
+                "model_used": self.model_name
+            }
+    
+    def _parse_processing_response(self, response: str) -> Dict[str, str]:
+        """
+        Extrai query SQL e observações da resposta
+
+        Args:
+            response: Resposta do modelo
+
+        Returns:
+            Dicionário com query e observações extraídas
+        """
+        try:
+            import re
+
+            query = ""
+            observations = ""
+
+            # Primeiro, tenta extrair observações pelo formato esperado
+            obs_match = re.search(r'Observações:\s*(.*?)(?:\n|$)', response, re.IGNORECASE)
+            if obs_match:
+                observations = obs_match.group(1).strip()
+
+            # Agora extrai a query SQL - prioriza blocos de código SQL
+            sql_patterns = [
+                # Padrão principal: ```sql ... ```
+                r'```sql\s*(.*?)\s*```',
+                # Padrão alternativo: ``` ... ``` (assumindo que é SQL)
+                r'```\s*(WITH.*?)\s*```',
+                r'```\s*(SELECT.*?)\s*```',
+                # Padrões sem backticks
+                r'Opção de querySQL:\s*(WITH.*?)(?=Observações:|$)',
+                r'Opção de querySQL:\s*(SELECT.*?)(?=Observações:|$)',
+                # Padrões mais gerais
+                r'(WITH\s+.*?;)',
+                r'(SELECT\s+.*?;)'
+            ]
+
+            for pattern in sql_patterns:
+                match = re.search(pattern, response, re.DOTALL | re.IGNORECASE)
+                if match:
+                    query = match.group(1).strip()
+                    break
+
+            # Limpa a query final se encontrada
+            if query:
+                # Remove apenas backticks e mantém formatação original
+                query = query.replace('```', '').replace('sql', '').strip()
+
+                # Remove quebras de linha no início e fim, mas mantém formatação interna
+                query = query.strip('\n').strip()
+
+            # Se ainda não encontrou observações, tenta padrão mais flexível
+            if not observations:
+                obs_patterns = [
+                    r'Observações:\s*(.*)',
+                    r'Observacoes:\s*(.*)',
+                ]
+                for pattern in obs_patterns:
+                    match = re.search(pattern, response, re.IGNORECASE | re.DOTALL)
+                    if match:
+                        observations = match.group(1).strip()
+                        break
+
+            return {
+                "question": "",  # Não precisamos da pergunta processada
+                "query": query,
+                "observations": observations
+            }
+
+        except Exception as e:
+            logging.error(f"Erro ao extrair query e observações: {e}")
+            return {
+                "question": "",
+                "query": "",
+                "observations": ""
+            }
+
+
+def get_default_processing_agent(model_name: str = "gpt-4o-mini") -> ProcessingAgentManager:
+    """
+    Cria um Processing Agent com configurações padrão
+    
+    Args:
+        model_name: Nome do modelo a usar
+        
+    Returns:
+        ProcessingAgentManager configurado
+    """
+    return ProcessingAgentManager(model_name)

agents/sql_agent.py

@@ -0,0 +1,392 @@
+"""
+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

@@ -0,0 +1,509 @@
+"""
+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
+    )
+
+# Função generate_initial_context removida - era redundante
+
+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_processing_context(user_query: str, db_sample: pd.DataFrame) -> str:
+    """
+    Prepara o contexto inicial para o Processing Agent
+
+    Args:
+        user_query: Pergunta do usuário
+        db_sample: Amostra dos dados do banco
+
+    Returns:
+        Contexto formatado para o Processing Agent
+    """
+    # Obtém informações detalhadas das colunas
+    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}")
+
+    columns_description = "\n".join(column_info)
+
+    # 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"
+
+    context = f"""
+    Você é um especialista em SQL que deve analisar a pergunta do usuário e gerar uma query SQL otimizada.
+
+    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"
+    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
+
+    CONTEXTO DOS DADOS:
+    Nome da tabela: tabela
+
+    Colunas disponíveis com tipos e exemplos:
+    {columns_description}
+
+    Exemplos de linhas dos dados:
+    {sample_data}
+
+    PERGUNTA DO USUÁRIO:
+    {user_query}
+
+    Responda somente nesse formato:
+
+    Opção de querySQL: [QuerySQL]
+    Observações: [Observações]
+    """
+
+    return context.strip()
+
+def prepare_sql_context(user_query: str, db_sample: pd.DataFrame, suggested_query: str = "", query_observations: str = "") -> 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
+        suggested_query: Query SQL sugerida pelo Processing Agent (opcional)
+        query_observations: Observações sobre a query sugerida (opcional)
+
+    Returns:
+        Contexto formatado para o agentSQL
+    """
+    import logging
+
+    # Contexto base
+    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"
+    )
+
+    # Contexto com opção de query (se disponível)
+    contexto_opcao_query = ""
+    if suggested_query and suggested_query.strip():
+        logging.info(f"[SQL CONTEXT] 🎯 Incluindo query sugerida no contexto do SQL Agent")
+
+        # Mantém formatação original da query
+        contexto_opcao_query = f"Opção de querySQL:\n```sql\n{suggested_query}\n```\n\n"
+
+        if query_observations and query_observations.strip():
+            contexto_opcao_query += f"Observações:\n{query_observations}\n\n"
+
+        contexto_opcao_query += "Você pode usar esta opção de query se ela estiver correta, ou criar sua própria query.\n\n"
+        logging.info(f"[SQL CONTEXT] ✅ Contexto do SQL Agent preparado COM sugestão de query")
+    else:
+        logging.info(f"[SQL CONTEXT] ℹ️ Contexto do SQL Agent preparado SEM sugestão de query")
+
+    # Monta contexto final
+    context = contexto_base + contexto_opcao_query + 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)

app.py

@@ -0,0 +1,487 @@
+"""
+AgentGraph - Aplicação principal com interface Gradio e LangGraph
+"""
+import asyncio
+import logging
+import gradio as gr
+import tempfile
+import os
+from typing import List, Tuple, Optional, Dict
+from PIL import Image
+
+from graphs.main_graph import initialize_graph, get_graph_manager
+from utils.config import (
+    AVAILABLE_MODELS,
+    REFINEMENT_MODELS,
+    DEFAULT_MODEL,
+    GRADIO_SHARE,
+    GRADIO_PORT,
+    validate_config,
+    is_langsmith_enabled,
+    LANGSMITH_PROJECT
+)
+from utils.object_manager import get_object_manager
+
+# Configuração de logging
+logging.basicConfig(
+    level=logging.INFO, 
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+# Variáveis globais
+graph_manager = None
+show_history_flag = False
+
+async def initialize_app():
+    """Inicializa a aplicação"""
+    global graph_manager
+    
+    try:
+        # Valida configurações
+        validate_config()
+        
+        # Inicializa o grafo
+        graph_manager = await initialize_graph()
+
+        # Informa sobre o status do LangSmith
+        if is_langsmith_enabled():
+            logging.info(f"✅ LangSmith habilitado - Projeto: '{LANGSMITH_PROJECT}'")
+            logging.info("🔍 Traces serão enviados para LangSmith automaticamente")
+        else:
+            logging.info("ℹ️ LangSmith não configurado - Executando sem observabilidade")
+
+        logging.info("Aplicação inicializada com sucesso")
+        return True
+        
+    except Exception as e:
+        logging.error(f"Erro ao inicializar aplicação: {e}")
+        return False
+
+def run_async(coro):
+    """Executa corrotina de forma síncrona"""
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    
+    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]]:
+    """
+    Processa resposta do chatbot usando LangGraph
+
+    Args:
+        user_input: Entrada do usuário
+        selected_model: Modelo LLM selecionado
+        advanced_mode: Se deve usar refinamento avançado
+        processing_enabled: Se o Processing Agent está habilitado
+        processing_model: Modelo para o Processing Agent
+
+    Returns:
+        Tupla com (resposta_texto, caminho_imagem_grafico)
+    """
+    global graph_manager
+
+    if not graph_manager:
+        return "❌ Sistema não inicializado. Tente recarregar a página.", None
+
+    try:
+        # Processa query através do LangGraph
+        result = run_async(graph_manager.process_query(
+            user_input=user_input,
+            selected_model=selected_model,
+            advanced_mode=advanced_mode,
+            processing_enabled=processing_enabled,
+            processing_model=processing_model
+        ))
+
+        response_text = result.get("response", "Erro ao processar resposta")
+        graph_image_path = None
+
+        # Verifica se foi gerado um gráfico
+        if result.get("graph_generated", False) and result.get("graph_image_id"):
+            graph_image_path = save_graph_image_to_temp(result["graph_image_id"])
+
+            # Adiciona informação sobre o gráfico na resposta
+            if graph_image_path:
+                graph_type = result.get("graph_type", "gráfico")
+                response_text += f"\n\n📊 **Gráfico gerado**: {graph_type.replace('_', ' ').title()}"
+
+        return response_text, graph_image_path
+
+    except Exception as e:
+        error_msg = f"Erro no chatbot: {e}"
+        logging.error(error_msg)
+        logging.error(f"Detalhes do erro: {type(e).__name__}: {str(e)}")
+        return error_msg, None
+
+def save_graph_image_to_temp(graph_image_id: str) -> Optional[str]:
+    """
+    Salva imagem do gráfico em arquivo temporário para exibição no Gradio
+
+    Args:
+        graph_image_id: ID da imagem no ObjectManager
+
+    Returns:
+        Caminho do arquivo temporário ou None se falhar
+    """
+    try:
+        obj_manager = get_object_manager()
+        graph_image = obj_manager.get_object(graph_image_id)
+
+        if graph_image and isinstance(graph_image, Image.Image):
+            # Cria arquivo temporário
+            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.png')
+            graph_image.save(temp_file.name, format='PNG')
+            temp_file.close()
+
+            logging.info(f"[GRADIO] Gráfico salvo em: {temp_file.name}")
+            return temp_file.name
+
+    except Exception as e:
+        logging.error(f"[GRADIO] Erro ao salvar gráfico: {e}")
+
+    return None
+
+def handle_csv_upload(file) -> str:
+    """
+    Processa upload de arquivo CSV
+
+    Args:
+        file: Arquivo enviado pelo Gradio
+
+    Returns:
+        Mensagem de feedback
+    """
+    global graph_manager
+
+    if not graph_manager:
+        return "❌ Sistema não inicializado."
+
+    if not file:
+        return "❌ Nenhum arquivo selecionado."
+
+    try:
+        # Log detalhado do arquivo recebido
+        logging.info(f"[UPLOAD] Arquivo recebido: {file}")
+        logging.info(f"[UPLOAD] Nome do arquivo: {file.name}")
+        logging.info(f"[UPLOAD] Tipo do arquivo: {type(file)}")
+
+        # Verifica se o arquivo existe
+        import os
+        if not os.path.exists(file.name):
+            return f"❌ Arquivo não encontrado: {file.name}"
+
+        # Verifica se é um arquivo CSV
+        if not file.name.lower().endswith('.csv'):
+            return "❌ Por favor, selecione um arquivo CSV válido."
+
+        # Verifica o tamanho do arquivo
+        file_size = os.path.getsize(file.name)
+        file_size_mb = file_size / (1024 * 1024)
+        file_size_gb = file_size / (1024 * 1024 * 1024)
+
+        if file_size_gb >= 1:
+            size_str = f"{file_size_gb:.2f} GB"
+        else:
+            size_str = f"{file_size_mb:.2f} MB"
+
+        logging.info(f"[UPLOAD] Tamanho do arquivo: {file_size} bytes ({size_str})")
+
+        if file_size == 0:
+            return "❌ O arquivo está vazio."
+
+        if file_size > 5 * 1024 * 1024 * 1024:  # 5GB
+            return "❌ Arquivo muito grande. Máximo permitido: 5GB."
+
+        # Aviso para arquivos grandes
+        if file_size_mb > 100:
+            logging.info(f"[UPLOAD] Arquivo grande detectado ({size_str}). Processamento pode demorar...")
+            return f"⏳ Processando arquivo grande ({size_str}). Aguarde..."
+
+        # Processa upload através do LangGraph
+        logging.info(f"[UPLOAD] Iniciando processamento do arquivo: {file.name}")
+        result = run_async(graph_manager.handle_csv_upload(file.name))
+
+        logging.info(f"[UPLOAD] Resultado do processamento: {result}")
+        return result.get("message", "Erro no upload")
+
+    except Exception as e:
+        error_msg = f"❌ Erro ao processar upload: {e}"
+        logging.error(error_msg)
+        logging.error(f"[UPLOAD] Detalhes do erro: {type(e).__name__}: {str(e)}")
+        import traceback
+        logging.error(f"[UPLOAD] Traceback: {traceback.format_exc()}")
+        return error_msg
+
+def reset_system() -> str:
+    """
+    Reseta o sistema ao estado inicial
+    
+    Returns:
+        Mensagem de feedback
+    """
+    global graph_manager
+    
+    if not graph_manager:
+        return "❌ Sistema não inicializado."
+    
+    try:
+        # Reseta sistema através do LangGraph
+        result = run_async(graph_manager.reset_system())
+        
+        return result.get("message", "Erro no reset")
+        
+    except Exception as e:
+        error_msg = f"❌ Erro ao resetar sistema: {e}"
+        logging.error(error_msg)
+        return error_msg
+
+def toggle_advanced_mode(enabled: bool) -> str:
+    """
+    Alterna modo avançado
+    
+    Args:
+        enabled: Se deve habilitar modo avançado
+        
+    Returns:
+        Mensagem de status
+    """
+    global graph_manager
+    
+    if not graph_manager:
+        return "❌ Sistema não inicializado."
+    
+    return graph_manager.toggle_advanced_mode(enabled)
+
+def toggle_history():
+    """Alterna exibição do histórico"""
+    global show_history_flag, graph_manager
+    
+    show_history_flag = not show_history_flag
+    
+    if show_history_flag and graph_manager:
+        return graph_manager.get_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"):
+    """
+    Função de resposta para o chatbot Gradio
+
+    Args:
+        message: Mensagem do usuário
+        chat_history: Histórico do chat (formato messages)
+        selected_model: Modelo selecionado
+        advanced_mode: Modo avançado habilitado
+        processing_enabled: Se o Processing Agent está habilitado
+        processing_model: Modelo para o Processing Agent
+
+    Returns:
+        Tupla com (mensagem_vazia, histórico_atualizado, imagem_grafico)
+    """
+    import logging
+
+    logging.info(f"[GRADIO RESPOND] ===== NOVA REQUISIÇÃO =====")
+    logging.info(f"[GRADIO RESPOND] Message: {message}")
+    logging.info(f"[GRADIO RESPOND] Selected model: {selected_model}")
+    logging.info(f"[GRADIO RESPOND] Advanced mode: {advanced_mode}")
+    logging.info(f"[GRADIO RESPOND] Processing enabled: {processing_enabled}")
+    logging.info(f"[GRADIO RESPOND] Processing model: {processing_model}")
+
+    if not message.strip():
+        return "", chat_history, None
+
+    # Processa resposta
+    response, graph_image_path = chatbot_response(message, selected_model, advanced_mode, processing_enabled, processing_model)
+
+    # Atualiza histórico no formato messages
+    chat_history.append({"role": "user", "content": message})
+    chat_history.append({"role": "assistant", "content": response})
+
+    return "", chat_history, graph_image_path
+
+def handle_csv_and_clear_chat(file):
+    """
+    Processa CSV e limpa chat
+
+    Args:
+        file: Arquivo CSV
+
+    Returns:
+        Tupla com (feedback, chat_limpo, grafico_limpo)
+    """
+    feedback = handle_csv_upload(file)
+    return feedback, [], gr.update(visible=False)
+
+def reset_all():
+    """
+    Reseta tudo e limpa interface
+
+    Returns:
+        Tupla com (feedback, chat_limpo, arquivo_limpo, grafico_limpo)
+    """
+    feedback = reset_system()
+    return feedback, [], None, gr.update(visible=False)
+
+# Interface Gradio
+def create_interface():
+    """Cria interface Gradio"""
+
+    # CSS customizado para pequeno espaçamento lateral
+    custom_css = """
+    .gradio-container {
+        padding: 20px 30px !important;
+    }
+    """
+
+    with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
+
+        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")
+                
+            with gr.Column(scale=4):
+                gr.Markdown("## Agent86")
+                chatbot = gr.Chatbot(
+                    height=600,
+                    show_label=False,
+                    container=True,
+                    type="messages"
+                )
+
+                msg = gr.Textbox(placeholder="Digite sua pergunta aqui...", lines=1, label="")
+                btn = gr.Button("Enviar", variant="primary")
+                history_btn = gr.Button("Histórico", variant="secondary")
+                history_output = gr.JSON()
+
+                # Componente para exibir gráficos - posicionado após histórico
+                graph_image = gr.Image(
+                    label="📊 Visualização de Dados",
+                    visible=False,
+                    height=500,  # Altura maior para ocupar mais espaço
+                    show_label=True,
+                    container=True,
+                    interactive=False,
+                    show_download_button=True
+                )
+
+                download_file = gr.File(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):
+            """Wrapper para lidar com resposta e gráfico"""
+            empty_msg, updated_history, graph_path = respond(message, chat_history, model, advanced, processing_enabled, processing_model)
+
+            # Controla visibilidade do componente de gráfico
+            if graph_path:
+                return empty_msg, updated_history, gr.update(value=graph_path, visible=True)
+            else:
+                return empty_msg, updated_history, gr.update(visible=False)
+
+        def toggle_processing_agent(enabled):
+            """Controla visibilidade do seletor de modelo do Processing Agent"""
+            return gr.update(visible=enabled)
+
+        msg.submit(
+            handle_response_with_graph,
+            inputs=[msg, chatbot, model_selector, advanced_checkbox, processing_checkbox, processing_model_selector],
+            outputs=[msg, chatbot, graph_image]
+        )
+
+        btn.click(
+            handle_response_with_graph,
+            inputs=[msg, chatbot, model_selector, advanced_checkbox, processing_checkbox, processing_model_selector],
+            outputs=[msg, chatbot, graph_image]
+        )
+
+        csv_file.change(
+            handle_csv_and_clear_chat,
+            inputs=csv_file,
+            outputs=[upload_feedback, chatbot, graph_image]
+        )
+
+        reset_btn.click(
+            reset_all,
+            outputs=[upload_feedback, chatbot, csv_file, graph_image]
+        )
+
+        advanced_checkbox.change(
+            toggle_advanced_mode,
+            inputs=advanced_checkbox,
+            outputs=[]
+        )
+
+        history_btn.click(
+            toggle_history,
+            outputs=history_output
+        )
+
+        processing_checkbox.change(
+            toggle_processing_agent,
+            inputs=processing_checkbox,
+            outputs=processing_model_selector
+        )
+    
+    return demo
+
+async def main():
+    """Função principal"""
+    # Inicializa aplicação
+    success = await initialize_app()
+
+    if not success:
+        logging.error("Falha na inicialização. Encerrando aplicação.")
+        return
+
+    # Cria e lança interface
+    demo = create_interface()
+
+    # Tenta diferentes portas se a padrão estiver ocupada
+    ports_to_try = [GRADIO_PORT, 7861, 7862, 7863, 7864, 0]  # 0 = porta automática
+
+    for port in ports_to_try:
+        try:
+            logging.info(f"Tentando iniciar interface Gradio na porta {port}")
+            demo.launch(
+                share=GRADIO_SHARE,
+                server_port=port if port != 0 else None,
+                show_error=True,
+                quiet=False
+            )
+            break  # Se chegou aqui, deu certo
+        except OSError as e:
+            if "Cannot find empty port" in str(e) and port != ports_to_try[-1]:
+                logging.warning(f"Porta {port} ocupada, tentando próxima...")
+                continue
+            else:
+                logging.error(f"Erro ao iniciar servidor: {e}")
+                raise
+        except Exception as e:
+            logging.error(f"Erro inesperado ao iniciar interface: {e}")
+            raise
+
+if __name__ == "__main__":
+    run_async(main())

graphs/main_graph.py

@@ -0,0 +1,827 @@
+"""
+Grafo principal do LangGraph para o AgentGraph
+"""
+import logging
+import pandas as pd
+import re
+from typing import Dict, Any, Optional
+from langgraph.graph import StateGraph, END
+from langgraph.checkpoint.memory import MemorySaver
+from sqlalchemy import Integer, Float, DateTime
+
+from nodes.agent_node import (
+    AgentState,
+    should_refine_response,
+    should_generate_graph,
+    should_use_processing_agent,
+    route_after_cache_check
+)
+from nodes.csv_processing_node import csv_processing_node
+from nodes.database_node import (
+    create_database_from_dataframe_node,
+    load_existing_database_node,
+    get_database_sample_node
+)
+from nodes.query_node import (
+    validate_query_input_node,
+    prepare_query_context_node,
+    process_user_query_node
+)
+from nodes.refinement_node import (
+    refine_response_node,
+    format_final_response_node
+)
+from nodes.processing_node import (
+    process_initial_context_node,
+    validate_processing_input_node
+)
+from nodes.cache_node import (
+    check_cache_node,
+    cache_response_node,
+    update_history_node
+)
+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 agents.sql_agent import SQLAgentManager
+from agents.tools import CacheManager
+from utils.database import create_sql_database
+from utils.config import get_active_csv_path, SQL_DB_PATH
+from utils.object_manager import get_object_manager
+
+class AgentGraphManager:
+    """
+    Gerenciador principal do grafo LangGraph
+    """
+    
+    def __init__(self):
+        self.graph = None
+        self.app = None
+        self.cache_manager = CacheManager()
+        self.custom_node_manager = CustomNodeManager()
+        self.object_manager = get_object_manager()
+        self.engine = None
+        self.sql_agent = None
+        self.db = None
+        # IDs para objetos não-serializáveis
+        self.agent_id = None
+        self.engine_id = None
+        self.db_id = None
+        self.cache_id = None
+        self._initialize_system()
+        self._build_graph()
+    
+    def _initialize_system(self):
+        """Inicializa o sistema com banco e agente padrão"""
+        try:
+            # Para inicialização síncrona, vamos usar load_existing_database_node de forma síncrona
+            # ou criar uma versão síncrona temporária
+            import os
+            from sqlalchemy import create_engine
+
+            # Verifica se banco existe
+            if os.path.exists(SQL_DB_PATH):
+                # Carrega banco existente
+                self.engine = create_engine(f"sqlite:///{SQL_DB_PATH}")
+                db = create_sql_database(self.engine)
+                logging.info("Banco existente carregado")
+            else:
+                # Cria novo banco usando função síncrona temporária
+                csv_path = get_active_csv_path()
+                self.engine = self._create_engine_sync(csv_path)
+                db = create_sql_database(self.engine)
+                logging.info("Novo banco criado")
+
+            # Armazena banco de dados
+            self.db = db
+            self.db_id = self.object_manager.store_database(db)
+
+            # Cria agente SQL
+            self.sql_agent = SQLAgentManager(db)
+
+            # Armazena objetos no gerenciador
+            self.agent_id = self.object_manager.store_sql_agent(self.sql_agent, self.db_id)
+            self.engine_id = self.object_manager.store_engine(self.engine)
+            self.cache_id = self.object_manager.store_cache_manager(self.cache_manager)
+
+            logging.info("Sistema inicializado com sucesso")
+
+        except Exception as e:
+            logging.error(f"Erro ao inicializar sistema: {e}")
+            raise
+
+    def _create_engine_sync(self, csv_path: str):
+        """Cria engine de forma síncrona para inicialização"""
+        import pandas as pd
+        from sqlalchemy import create_engine
+        from sqlalchemy.types import DateTime, Integer, Float
+
+        # Lê CSV
+        df = pd.read_csv(csv_path, sep=';')
+
+        # Processamento inteligente de tipos
+        sql_types = {}
+        df = self._smart_type_conversion(df, sql_types)
+
+        # Cria engine e salva dados
+        engine = create_engine(f"sqlite:///{SQL_DB_PATH}")
+        df.to_sql("tabela", engine, index=False, if_exists="replace", dtype=sql_types)
+
+        logging.info(f"Banco criado com {len(df)} registros")
+        return engine
+    
+    def _build_graph(self):
+        """Constrói o grafo LangGraph com nova arquitetura"""
+        try:
+            # Cria o StateGraph
+            workflow = StateGraph(AgentState)
+
+            # 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)
+            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)
+            workflow.add_node("get_db_sample", get_database_sample_node)
+
+            # Adiciona nós de processamento
+            workflow.add_node("process_query", process_user_query_node)
+
+            # Adiciona nós de gráficos
+            workflow.add_node("graph_selection", graph_selection_node)
+            workflow.add_node("graph_generation", graph_generation_node)
+
+            # Adiciona nós de refinamento
+            workflow.add_node("refine_response", refine_response_node)
+            workflow.add_node("format_response", format_final_response_node)
+
+            # Adiciona nós de cache e histórico
+            workflow.add_node("cache_response", cache_response_node)
+            workflow.add_node("update_history", update_history_node)
+
+            # Define ponto de entrada
+            workflow.set_entry_point("validate_input")
+
+            # Fluxo principal
+            workflow.add_edge("validate_input", "check_cache")
+
+            # Condicional para cache hit ou processing
+            workflow.add_conditional_edges(
+                "check_cache",
+                route_after_cache_check,
+                {
+                    "update_history": "update_history",
+                    "validate_processing": "validate_processing",
+                    "prepare_context": "prepare_context"
+                }
+            )
+
+            # 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", "get_db_sample")
+            workflow.add_edge("get_db_sample", "process_query")
+
+            # Condicional para gráficos (após AgentSQL)
+            workflow.add_conditional_edges(
+                "process_query",
+                should_generate_graph,
+                {
+                    "graph_selection": "graph_selection",
+                    "refine_response": "refine_response",
+                    "cache_response": "cache_response"
+                }
+            )
+
+            # Fluxo dos gráficos
+            workflow.add_edge("graph_selection", "graph_generation")
+
+            # Após geração de gráfico, vai para refinamento ou cache
+            workflow.add_conditional_edges(
+                "graph_generation",
+                should_refine_response,
+                {
+                    "refine_response": "refine_response",
+                    "cache_response": "cache_response"
+                }
+            )
+
+            workflow.add_edge("refine_response", "format_response")
+            workflow.add_edge("format_response", "cache_response")
+            workflow.add_edge("cache_response", "update_history")
+            workflow.add_edge("update_history", END)
+
+            # Compila o grafo
+            memory = MemorySaver()
+            self.app = workflow.compile(checkpointer=memory)
+
+            logging.info("Grafo LangGraph construído com sucesso")
+
+        except Exception as e:
+            logging.error(f"Erro ao construir grafo: {e}")
+            raise
+    
+    async def process_query(
+        self,
+        user_input: str,
+        selected_model: str = "GPT-4o-mini",
+        advanced_mode: bool = False,
+        processing_enabled: bool = False,
+        processing_model: str = "GPT-4o-mini",
+        thread_id: str = "default"
+    ) -> Dict[str, Any]:
+        """
+        Processa uma query do usuário através do grafo
+
+        Args:
+            user_input: Entrada do usuário
+            selected_model: Modelo LLM selecionado
+            advanced_mode: Se deve usar refinamento avançado
+            processing_enabled: Se deve usar o Processing Agent
+            processing_model: Modelo para o Processing Agent
+            thread_id: ID da thread para checkpoint
+
+        Returns:
+            Resultado do processamento
+        """
+        try:
+            # Verifica se precisa recriar agente SQL com modelo diferente
+            current_sql_agent = self.object_manager.get_sql_agent(self.agent_id)
+            if current_sql_agent and current_sql_agent.model_name != selected_model:
+                logging.info(f"Recriando agente SQL com modelo {selected_model}")
+
+                # Recupera banco de dados associado ao agente
+                db_id = self.object_manager.get_db_id_for_agent(self.agent_id)
+                if db_id:
+                    db = self.object_manager.get_database(db_id)
+                    if db:
+                        new_sql_agent = SQLAgentManager(db, selected_model)
+                        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:
+                        logging.error("Banco de dados não encontrado para recriar agente")
+                else:
+                    logging.error("ID do banco de dados não encontrado para o agente")
+
+            # Log dos parâmetros recebidos
+            logging.info(f"[MAIN GRAPH] ===== INICIANDO PROCESSAMENTO DE QUERY =====")
+            logging.info(f"[MAIN GRAPH] User input: {user_input}")
+            logging.info(f"[MAIN GRAPH] Selected model: {selected_model}")
+            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}")
+
+            # Prepara estado inicial com IDs serializáveis
+            initial_state = {
+                "user_input": user_input,
+                "selected_model": selected_model,
+                "response": "",
+                "advanced_mode": advanced_mode,
+                "execution_time": 0.0,
+                "error": None,
+                "intermediate_steps": [],
+                "db_sample_dict": {},
+                # IDs para recuperar objetos não-serializáveis
+                "agent_id": self.agent_id,
+                "engine_id": self.engine_id,
+                "db_id": self.db_id,
+                "cache_id": self.cache_id,
+                # Campos relacionados a gráficos
+                "query_type": "sql_query",  # Será atualizado pela detecção
+                "sql_query_extracted": None,
+                "graph_type": None,
+                "graph_data": None,
+                "graph_image_id": None,
+                "graph_generated": False,
+                "graph_error": None,
+                # Campos relacionados ao cache
+                "cache_hit": False,
+                # Campos relacionados ao Processing Agent
+                "processing_enabled": processing_enabled,
+                "processing_model": processing_model,
+                "processing_agent_id": None,
+                "suggested_query": None,
+                "query_observations": None,
+                "processing_result": None,
+                "processing_success": False,
+                "processing_error": None,
+                # Campos relacionados ao refinamento
+                "refined": False,
+                "refinement_error": None,
+                "refinement_quality": None,
+                "quality_metrics": None,
+                # Campos relacionados ao contexto SQL
+                "sql_context": None,
+                "sql_result": None
+            }
+            
+            # Executa o grafo
+            config = {"configurable": {"thread_id": thread_id}}
+            result = await self.app.ainvoke(initial_state, config=config)
+            
+            logging.info(f"Query processada com sucesso: {user_input[:50]}...")
+            return result
+            
+        except Exception as e:
+            error_msg = f"Erro ao processar query: {e}"
+            logging.error(error_msg)
+            return {
+                "user_input": user_input,
+                "response": error_msg,
+                "error": error_msg,
+                "execution_time": 0.0
+            }
+    
+    async def handle_csv_upload(self, file_path: str) -> Dict[str, Any]:
+        """
+        Processa upload de CSV usando nova arquitetura de nós
+
+        Args:
+            file_path: Caminho do arquivo CSV
+
+        Returns:
+            Resultado do upload
+        """
+        try:
+            # Etapa 1: Processa CSV
+            csv_state = {
+                "file_path": file_path,
+                "success": False,
+                "message": "",
+                "csv_data_sample": {},
+                "column_info": {},
+                "processing_stats": {}
+            }
+
+            csv_result = await csv_processing_node(csv_state)
+
+            if not csv_result["success"]:
+                return csv_result
+
+            # Etapa 2: Cria banco de dados
+            db_state = csv_result.copy()
+            db_result = await create_database_from_dataframe_node(db_state)
+
+            if not db_result["success"]:
+                return db_result
+
+            # Etapa 3: Atualiza sistema
+            if db_result["success"]:
+                # Atualiza IDs dos objetos
+                self.engine_id = db_result["engine_id"]
+                self.db_id = db_result["db_id"]
+
+                # Cria novo agente SQL
+                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)
+
+                # Atualiza agente
+                self.agent_id = self.object_manager.store_sql_agent(new_sql_agent, self.db_id)
+
+                # Limpa cache
+                cache_manager = self.object_manager.get_cache_manager(self.cache_id)
+                if cache_manager:
+                    cache_manager.clear_cache()
+
+                logging.info("[UPLOAD] Sistema atualizado com novo CSV")
+
+            return db_result
+
+        except Exception as e:
+            error_msg = f"❌ Erro no upload de CSV: {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
+
+        Returns:
+            Resultado do reset
+        """
+        try:
+            # Usa nó de reset customizado
+            state = {
+                "success": False,
+                "message": "",
+                "engine_id": self.engine_id,
+                "agent_id": self.agent_id,
+                "cache_id": self.cache_id
+            }
+
+            result = await self.custom_node_manager.execute_node("system_reset", state)
+
+            # Se reset foi bem-sucedido, atualiza IDs
+            if result.get("success"):
+                self.engine_id = result.get("engine_id", self.engine_id)
+                self.agent_id = result.get("agent_id", self.agent_id)
+                # Cache ID permanece o mesmo, apenas é limpo
+
+                logging.info("[RESET] Sistema resetado com sucesso")
+
+            return result
+
+        except Exception as e:
+            error_msg = f"❌ Erro ao resetar sistema: {e}"
+            logging.error(error_msg)
+            return {
+                "success": False,
+                "message": error_msg
+            }
+    
+    def toggle_advanced_mode(self, enabled: bool) -> str:
+        """
+        Alterna modo avançado
+        
+        Args:
+            enabled: Se deve habilitar modo avançado
+            
+        Returns:
+            Mensagem de status
+        """
+        message = "Modo avançado ativado." if enabled else "Modo avançado desativado."
+        logging.info(f"[MODO AVANÇADO] {'Ativado' if enabled else 'Desativado'}")
+        return message
+    
+    def get_history(self) -> list:
+        """
+        Retorna histórico de conversas
+        
+        Returns:
+            Lista com histórico
+        """
+        return self.cache_manager.get_history()
+    
+    def clear_cache(self):
+        """Limpa cache do sistema"""
+        self.cache_manager.clear_cache()
+        logging.info("Cache limpo")
+    
+    async def get_system_info(self) -> Dict[str, Any]:
+        """
+        Obtém informações do sistema
+        
+        Returns:
+            Informações do sistema
+        """
+        state = {
+            "engine": self.engine,
+            "sql_agent": self.sql_agent,
+            "cache_manager": self.cache_manager
+        }
+        
+        result = await self.custom_node_manager.execute_node("system_info", state)
+        return result.get("system_info", {})
+    
+    async def validate_system(self) -> Dict[str, Any]:
+        """
+        Valida o estado do sistema
+        
+        Returns:
+            Resultado da validação
+        """
+        state = {
+            "engine": self.engine,
+            "sql_agent": self.sql_agent,
+            "cache_manager": self.cache_manager
+        }
+        
+        result = await self.custom_node_manager.execute_node("system_validation", state)
+        return result.get("validation", {})
+
+    def _smart_type_conversion(self, df, sql_types):
+        """
+        Conversão inteligente de tipos de dados com suporte a formatos brasileiros
+        """
+        import re
+
+        logging.info("[TYPE_CONVERSION] 🔧 Iniciando conversão inteligente de tipos")
+
+        for col in df.columns:
+            col_data = df[col].dropna()  # Remove NaN para análise
+
+            if len(col_data) == 0:
+                continue
+
+            # Amostra para análise (primeiros 100 valores não-nulos)
+            sample = col_data.head(100).astype(str)
+
+            logging.debug(f"[TYPE_CONVERSION] 📊 Analisando coluna: {col}")
+
+            # 1. DETECTAR DATAS
+            if self._is_date_column(sample):
+                try:
+                    df[col] = self._convert_to_date(df[col])
+                    sql_types[col] = DateTime
+                    logging.debug(f"[TYPE_CONVERSION] ✅ {col} → DATETIME")
+                    continue
+                except Exception as e:
+                    logging.warning(f"[TYPE_CONVERSION] ⚠️ Falha ao converter {col} para data: {e}")
+
+            # 2. DETECTAR NÚMEROS INTEIROS (PRIORIDADE ALTA)
+            if self._is_integer_column(sample):
+                try:
+                    # Converter removendo caracteres não numéricos, mas mantendo negativos
+                    def clean_integer(value):
+                        if pd.isna(value):
+                            return None
+                        value_str = str(value).strip()
+                        # Manter apenas dígitos e sinal negativo
+                        clean_value = ''.join(c for c in value_str if c.isdigit() or c == '-')
+                        if clean_value and clean_value != '-':
+                            return int(clean_value)
+                        return None
+
+                    df[col] = df[col].apply(clean_integer).astype('Int64')
+                    sql_types[col] = Integer
+                    logging.debug(f"[TYPE_CONVERSION] ✅ {col} → INTEGER")
+                    continue
+                except Exception as e:
+                    logging.warning(f"[TYPE_CONVERSION] ⚠️ Falha ao converter {col} para inteiro: {e}")
+
+            # 3. DETECTAR VALORES MONETÁRIOS
+            if self._is_monetary_column(sample):
+                try:
+                    df[col] = self._convert_to_monetary(df[col])
+                    sql_types[col] = Float
+                    logging.debug(f"[TYPE_CONVERSION] ✅ {col} → FLOAT (monetário)")
+                    continue
+                except Exception as e:
+                    logging.warning(f"[TYPE_CONVERSION] ⚠️ Falha ao converter {col} para monetário: {e}")
+
+            # 4. DETECTAR NÚMEROS DECIMAIS
+            if self._is_float_column(sample):
+                try:
+                    df[col] = self._convert_to_float(df[col])
+                    sql_types[col] = Float
+                    logging.debug(f"[TYPE_CONVERSION] ✅ {col} → FLOAT")
+                    continue
+                except Exception as e:
+                    logging.warning(f"[TYPE_CONVERSION] ⚠️ Falha ao converter {col} para float: {e}")
+
+            # 5. MANTER COMO TEXTO (padrão)
+            logging.debug(f"[TYPE_CONVERSION] 📝 {col} → TEXT (padrão)")
+
+        # Resumo da conversão
+        type_summary = {}
+        for col, sql_type in sql_types.items():
+            type_name = sql_type.__name__ if hasattr(sql_type, '__name__') else str(sql_type).split('.')[-1].replace('>', '')
+            if type_name not in type_summary:
+                type_summary[type_name] = 0
+            type_summary[type_name] += 1
+
+        summary_text = ", ".join([f"{count} {type_name}" for type_name, count in type_summary.items()])
+        logging.info(f"[TYPE_CONVERSION] ✅ Conversão concluída: {summary_text}")
+        return df
+
+    def _is_date_column(self, sample):
+        """Detecta se uma coluna contém datas BASEADO APENAS NOS VALORES"""
+        import re
+
+        # Padrões de data brasileiros e internacionais
+        date_patterns = [
+            r'^\d{1,2}[\/\-\.]\d{1,2}[\/\-\.]\d{4}$',  # DD/MM/YYYY ou DD-MM-YYYY
+            r'^\d{4}[\/\-\.]\d{1,2}[\/\-\.]\d{1,2}$',  # YYYY/MM/DD ou YYYY-MM-DD
+            r'^\d{1,2}[\/\-\.]\d{1,2}[\/\-\.]\d{2}$',  # DD/MM/YY
+        ]
+
+        # Verificar se pelo menos 70% dos valores seguem padrão de data
+        date_count = 0
+        for value in sample:
+            if pd.isna(value) or value == '':
+                continue
+            for pattern in date_patterns:
+                if re.match(pattern, str(value).strip()):
+                    date_count += 1
+                    break
+
+        return date_count / len(sample) >= 0.7
+
+    def _is_monetary_column(self, sample):
+        """Detecta se uma coluna contém valores monetários BASEADO APENAS NOS VALORES"""
+        import re
+
+        # Padrões monetários brasileiros e internacionais
+        money_patterns = [
+            r'^R\$\s*\d+[,\.]\d{2}$',  # R$ 10,50 ou R$ 10.50
+            r'^\d+[,\.]\d{2}$',        # 10,50 ou 10.50
+            r'^R\$\s*\d+$',            # R$ 10
+            r'^\$\s*\d+[,\.]\d{2}$',   # $ 10.50
+            r'^\$\s*\d+$',             # $ 10
+        ]
+
+        # Verificar se pelo menos 60% dos valores seguem padrão monetário
+        money_count = 0
+        for value in sample:
+            if pd.isna(value) or value == '':
+                continue
+            value_str = str(value).strip()
+            for pattern in money_patterns:
+                if re.match(pattern, value_str):
+                    money_count += 1
+                    break
+
+        return money_count / len(sample) >= 0.6
+
+    def _is_integer_column(self, sample):
+        """Detecta se uma coluna contém números inteiros"""
+        try:
+            # Primeiro, verificar se há vírgulas ou pontos decimais nos valores
+            has_decimal_separators = False
+            valid_numeric_count = 0
+            integer_count = 0
+
+            for value in sample:
+                if pd.isna(value) or value == '':
+                    continue
+
+                value_str = str(value).strip()
+
+                # Se contém vírgula ou ponto seguido de dígitos, é decimal
+                if (',' in value_str and any(c.isdigit() for c in value_str.split(',')[-1])) or \
+                   ('.' in value_str and any(c.isdigit() for c in value_str.split('.')[-1])):
+                    has_decimal_separators = True
+                    break
+
+                # Tentar converter para número
+                try:
+                    # Remover espaços e caracteres não numéricos (exceto - para negativos)
+                    clean_value = ''.join(c for c in value_str if c.isdigit() or c == '-')
+                    if clean_value and clean_value != '-':
+                        num_value = int(clean_value)
+                        valid_numeric_count += 1
+                        integer_count += 1
+                except:
+                    # Se não conseguir converter para int, tentar float
+                    try:
+                        float_value = float(value_str)
+                        valid_numeric_count += 1
+                        # Se o float é igual ao int, conta como inteiro
+                        if float_value == int(float_value):
+                            integer_count += 1
+                    except:
+                        continue
+
+            # Se encontrou separadores decimais, não é coluna de inteiros
+            if has_decimal_separators:
+                return False
+
+            # Verificar se pelo menos 80% são números válidos
+            if valid_numeric_count == 0 or valid_numeric_count / len(sample) < 0.8:
+                return False
+
+            # Verificar se pelo menos 95% dos números válidos são inteiros
+            return integer_count / valid_numeric_count >= 0.95
+
+        except Exception as e:
+            logging.debug(f"Erro na detecção de inteiros: {e}")
+            return False
+
+    def _is_float_column(self, sample):
+        """Detecta se uma coluna contém números decimais (com vírgula ou ponto)"""
+        try:
+            has_decimal_values = False
+            valid_numeric_count = 0
+
+            for value in sample:
+                if pd.isna(value) or value == '':
+                    continue
+
+                value_str = str(value).strip()
+
+                # Verificar se contém separadores decimais com dígitos após
+                if (',' in value_str and any(c.isdigit() for c in value_str.split(',')[-1])) or \
+                   ('.' in value_str and any(c.isdigit() for c in value_str.split('.')[-1])):
+                    has_decimal_values = True
+
+                # Tentar converter para numérico (substituindo vírgula por ponto)
+                try:
+                    clean_value = value_str.replace(',', '.')
+                    float(clean_value)
+                    valid_numeric_count += 1
+                except:
+                    continue
+
+            # Só é float se tem separadores decimais E pelo menos 80% são números válidos
+            if not has_decimal_values:
+                return False
+
+            return valid_numeric_count / len(sample) >= 0.8
+
+        except Exception as e:
+            logging.debug(f"Erro na detecção de floats: {e}")
+            return False
+
+    def _convert_to_date(self, series):
+        """Converte série para datetime com formatos brasileiros"""
+        # Tentar diferentes formatos de data
+        date_formats = [
+            '%d/%m/%Y',    # 31/12/2023
+            '%d-%m-%Y',    # 31-12-2023
+            '%d.%m.%Y',    # 31.12.2023
+            '%Y-%m-%d',    # 2023-12-31
+            '%Y/%m/%d',    # 2023/12/31
+            '%d/%m/%y',    # 31/12/23
+        ]
+
+        for fmt in date_formats:
+            try:
+                return pd.to_datetime(series, format=fmt, errors='raise')
+            except:
+                continue
+
+        # Se nenhum formato específico funcionou, usar inferência automática
+        try:
+            return pd.to_datetime(series, dayfirst=True, errors='coerce')
+        except:
+            raise ValueError("Não foi possível converter para data")
+
+    def _convert_to_monetary(self, series):
+        """Converte série para valores monetários (float)"""
+        def clean_monetary(value):
+            if pd.isna(value):
+                return None
+
+            # Converter para string e limpar
+            value_str = str(value).strip()
+
+            # Remover símbolos monetários
+            value_str = value_str.replace('R$', '').replace('$', '').strip()
+
+            # Tratar formato brasileiro (vírgula como decimal)
+            if ',' in value_str and '.' in value_str:
+                # Formato: 1.234,56 → 1234.56
+                value_str = value_str.replace('.', '').replace(',', '.')
+            elif ',' in value_str:
+                # Formato: 1234,56 → 1234.56
+                value_str = value_str.replace(',', '.')
+
+            try:
+                return float(value_str)
+            except:
+                return None
+
+        return series.apply(clean_monetary)
+
+    def _convert_to_float(self, series):
+        """Converte série para float com formato brasileiro"""
+        def clean_float(value):
+            if pd.isna(value):
+                return None
+
+            value_str = str(value).strip()
+
+            # Tratar formato brasileiro
+            if ',' in value_str:
+                value_str = value_str.replace(',', '.')
+
+            try:
+                return float(value_str)
+            except:
+                return None
+
+        return series.apply(clean_float)
+
+# Instância global do gerenciador
+_graph_manager: Optional[AgentGraphManager] = None
+
+def get_graph_manager() -> AgentGraphManager:
+    """
+    Retorna instância singleton do gerenciador de grafo
+    
+    Returns:
+        AgentGraphManager
+    """
+    global _graph_manager
+    if _graph_manager is None:
+        _graph_manager = AgentGraphManager()
+    return _graph_manager
+
+async def initialize_graph() -> AgentGraphManager:
+    """
+    Inicializa o grafo principal
+    
+    Returns:
+        AgentGraphManager inicializado
+    """
+    try:
+        manager = get_graph_manager()
+        
+        # Valida sistema
+        validation = await manager.validate_system()
+        if not validation.get("overall_valid", False):
+            logging.warning("Sistema não passou na validação completa")
+        
+        logging.info("Grafo principal inicializado e validado")
+        return manager
+        
+    except Exception as e:
+        logging.error(f"Erro ao inicializar grafo: {e}")
+        raise
+
+# Classe GraphManager removida - funcionalidade movida para AgentGraphManager

nodes/agent_node.py

@@ -0,0 +1,136 @@
+"""
+Definições do estado do agente e funções de coordenação geral
+"""
+from typing import Dict, Any, Optional, TypedDict
+
+
+class AgentState(TypedDict):
+    """Estado do agente LangGraph - apenas dados serializáveis"""
+    user_input: str
+    selected_model: str
+    response: str
+    advanced_mode: bool
+    execution_time: float
+    error: Optional[str]
+    intermediate_steps: list
+    
+    # Dados serializáveis do banco
+    db_sample_dict: dict
+    
+    # IDs para recuperar objetos não-serializáveis
+    agent_id: str
+    engine_id: str
+    cache_id: str
+    
+    # Campos relacionados a gráficos
+    query_type: str  # 'sql_query', 'sql_query_graphic', 'prediction'
+    sql_query_extracted: Optional[str]  # Query SQL extraída da resposta do agente
+    graph_type: Optional[str]  # Tipo de gráfico escolhido pela LLM
+    graph_data: Optional[dict]  # Dados preparados para o gráfico (serializável)
+    graph_image_id: Optional[str]  # ID da imagem do gráfico no ObjectManager
+    graph_generated: bool  # Se o gráfico foi gerado com sucesso
+    graph_error: Optional[str]  # Erro na geração de gráfico
+    
+    # Campos relacionados ao cache
+    cache_hit: bool  # Se houve hit no cache
+    
+    # Campos relacionados ao Processing Agent
+    processing_enabled: bool  # Se o Processing Agent está habilitado
+    processing_model: str  # Modelo usado no Processing Agent
+    processing_agent_id: Optional[str]  # ID do Processing Agent no ObjectManager
+    suggested_query: Optional[str]  # Query SQL sugerida pelo Processing Agent
+    query_observations: Optional[str]  # Observações sobre a query sugerida
+    processing_result: Optional[dict]  # Resultado completo do Processing Agent
+    processing_success: bool  # Se o processamento foi bem-sucedido
+    processing_error: Optional[str]  # Erro no processamento
+    
+    # Campos relacionados ao refinamento
+    refined: bool  # Se a resposta foi refinada
+    refinement_error: Optional[str]  # Erro no refinamento
+    refinement_quality: Optional[str]  # Qualidade do refinamento
+    quality_metrics: Optional[dict]  # Métricas de qualidade
+    
+    # Campos relacionados ao contexto SQL
+    sql_context: Optional[str]  # Contexto preparado para o agente SQL
+    sql_result: Optional[dict]  # Resultado do agente SQL
+
+
+def should_refine_response(state: Dict[str, Any]) -> str:
+    """
+    Determina se deve refinar a resposta
+    
+    Args:
+        state: Estado atual
+        
+    Returns:
+        Nome do próximo nó
+    """
+    if state.get("advanced_mode", False) and not state.get("error"):
+        return "refine_response"
+    else:
+        return "cache_response"
+
+
+def should_generate_graph(state: Dict[str, Any]) -> str:
+    """
+    Determina se deve gerar gráfico
+    
+    Args:
+        state: Estado atual
+        
+    Returns:
+        Nome do próximo nó
+    """
+    query_type = state.get("query_type", "")
+    
+    if query_type == "sql_query_graphic" and not state.get("error"):
+        return "graph_selection"
+    elif state.get("advanced_mode", False) and not state.get("error"):
+        return "refine_response"
+    else:
+        return "cache_response"
+
+
+def should_use_processing_agent(state: Dict[str, Any]) -> str:
+    """
+    Determina se deve usar o Processing Agent
+    
+    Args:
+        state: Estado atual
+        
+    Returns:
+        Nome do próximo nó
+    """
+    if state.get("processing_enabled", False):
+        return "validate_processing"
+    else:
+        return "prepare_context"
+
+
+def route_after_cache_check(state: Dict[str, Any]) -> str:
+    """
+    Roteamento após verificação de cache
+
+    Args:
+        state: Estado atual
+
+    Returns:
+        Nome do próximo nó
+    """
+    import logging
+
+    cache_hit = state.get("cache_hit", False)
+    processing_enabled = state.get("processing_enabled", False)
+
+    logging.info(f"[ROUTING] Cache hit: {cache_hit}")
+    logging.info(f"[ROUTING] Processing enabled: {processing_enabled}")
+
+    if cache_hit:
+        logging.info("[ROUTING] Direcionando para update_history (cache hit)")
+        return "update_history"
+    elif processing_enabled:
+        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"

nodes/cache_node.py

@@ -0,0 +1,230 @@
+"""
+Nó para gerenciamento de cache e histórico
+"""
+import logging
+from typing import Dict, Any
+
+from utils.object_manager import get_object_manager
+
+async def update_history_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para atualizar histórico e logs
+    
+    Args:
+        state: Estado atual do agente
+        
+    Returns:
+        Estado atualizado
+    """
+    try:
+        obj_manager = get_object_manager()
+        cache_id = state.get("cache_id")
+        
+        if not cache_id:
+            logging.warning("[HISTORY] ID do cache não encontrado")
+            return state
+        
+        cache_manager = obj_manager.get_cache_manager(cache_id)
+        if not cache_manager:
+            logging.warning("[HISTORY] Cache manager não encontrado")
+            return state
+        
+        # Adiciona ao histórico de logs
+        history_entry = {
+            "Modelo AgentSQL": state.get("selected_model", ""),
+            "Pergunta": state.get("user_input", ""),
+            "Resposta": state.get("response", ""),
+            "Tempo de Resposta (s)": round(state.get("execution_time", 0.0), 2),
+            "Modo Avançado": state.get("advanced_mode", False),
+            "Refinado": state.get("refined", False),
+            "Erro": state.get("error"),
+            "Tipo de Query": state.get("query_type", "sql_query")
+        }
+        cache_manager.add_to_history(history_entry)
+        
+        # Atualiza histórico recente
+        cache_manager.update_recent_history(
+            state.get("user_input", ""), 
+            state.get("response", "")
+        )
+        
+        state["history_updated"] = True
+        logging.info("[HISTORY] Histórico atualizado")
+        
+    except Exception as e:
+        error_msg = f"Erro ao atualizar histórico: {e}"
+        logging.error(f"[HISTORY] {error_msg}")
+        state["history_error"] = error_msg
+    
+    return state
+
+async def cache_response_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para armazenar resposta no cache
+    
+    Args:
+        state: Estado com resposta a ser cacheada
+        
+    Returns:
+        Estado atualizado
+    """
+    try:
+        obj_manager = get_object_manager()
+        cache_id = state.get("cache_id")
+        
+        if not cache_id:
+            logging.warning("[CACHE] ID do cache não encontrado")
+            return state
+        
+        cache_manager = obj_manager.get_cache_manager(cache_id)
+        if not cache_manager:
+            logging.warning("[CACHE] Cache manager não encontrado")
+            return state
+        
+        user_input = state.get("user_input", "")
+        response = state.get("response", "")
+        
+        if user_input and response and not state.get("error"):
+            cache_manager.cache_response(user_input, response)
+            state["cached"] = True
+            logging.info(f"[CACHE] Resposta cacheada para: {user_input[:50]}...")
+        else:
+            state["cached"] = False
+            logging.info("[CACHE] Resposta não cacheada (erro ou dados insuficientes)")
+        
+    except Exception as e:
+        error_msg = f"Erro ao cachear resposta: {e}"
+        logging.error(f"[CACHE] {error_msg}")
+        state["cache_error"] = error_msg
+    
+    return state
+
+async def get_cache_stats_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para obter estatísticas do cache
+    
+    Args:
+        state: Estado atual
+        
+    Returns:
+        Estado com estatísticas do cache
+    """
+    try:
+        obj_manager = get_object_manager()
+        cache_id = state.get("cache_id")
+        
+        if not cache_id:
+            state["cache_stats"] = {}
+            return state
+        
+        cache_manager = obj_manager.get_cache_manager(cache_id)
+        if not cache_manager:
+            state["cache_stats"] = {}
+            return state
+        
+        # Coleta estatísticas
+        cache_stats = {
+            "cached_queries": len(cache_manager.query_cache),
+            "history_entries": len(cache_manager.history_log),
+            "recent_history_size": len(cache_manager.recent_history),
+            "cache_hit_rate": 0.0  # Seria calculado com mais dados históricos
+        }
+        
+        # Calcula taxa de acerto aproximada
+        if cache_stats["history_entries"] > 0:
+            # Estimativa simples baseada em queries repetidas
+            unique_queries = len(set(entry.get("Pergunta", "") for entry in cache_manager.history_log))
+            if unique_queries > 0:
+                cache_stats["cache_hit_rate"] = max(0, 1 - (unique_queries / cache_stats["history_entries"]))
+        
+        state["cache_stats"] = cache_stats
+        logging.info(f"[CACHE] Estatísticas coletadas: {cache_stats}")
+        
+    except Exception as e:
+        error_msg = f"Erro ao obter estatísticas do cache: {e}"
+        logging.error(f"[CACHE] {error_msg}")
+        state["cache_stats"] = {}
+    
+    return state
+
+async def clear_cache_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para limpar cache
+    
+    Args:
+        state: Estado atual
+        
+    Returns:
+        Estado atualizado
+    """
+    try:
+        obj_manager = get_object_manager()
+        cache_id = state.get("cache_id")
+        
+        if not cache_id:
+            state["cache_cleared"] = False
+            return state
+        
+        cache_manager = obj_manager.get_cache_manager(cache_id)
+        if not cache_manager:
+            state["cache_cleared"] = False
+            return state
+        
+        # Limpa cache
+        cache_manager.clear_cache()
+        state["cache_cleared"] = True
+        
+        logging.info("[CACHE] Cache limpo")
+        
+    except Exception as e:
+        error_msg = f"Erro ao limpar cache: {e}"
+        logging.error(f"[CACHE] {error_msg}")
+        state["cache_cleared"] = False
+        state["cache_error"] = error_msg
+    
+    return state
+
+async def check_cache_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para verificar se existe resposta em cache
+    
+    Args:
+        state: Estado com consulta do usuário
+        
+    Returns:
+        Estado com resultado da verificação de cache
+    """
+    try:
+        obj_manager = get_object_manager()
+        cache_id = state.get("cache_id")
+        user_input = state.get("user_input", "")
+        
+        if not cache_id or not user_input:
+            state["cache_hit"] = False
+            return state
+        
+        cache_manager = obj_manager.get_cache_manager(cache_id)
+        if not cache_manager:
+            state["cache_hit"] = False
+            return state
+        
+        # Verifica cache
+        cached_response = cache_manager.get_cached_response(user_input)
+        
+        if cached_response:
+            state["cache_hit"] = True
+            state["response"] = cached_response
+            state["execution_time"] = 0.0
+            state["error"] = None
+            logging.info(f"[CACHE] Hit para: {user_input[:50]}...")
+        else:
+            state["cache_hit"] = False
+            logging.info(f"[CACHE] Miss para: {user_input[:50]}...")
+        
+    except Exception as e:
+        error_msg = f"Erro ao verificar cache: {e}"
+        logging.error(f"[CACHE] {error_msg}")
+        state["cache_hit"] = False
+        state["cache_error"] = error_msg
+    
+    return state

nodes/csv_processing_node.py

@@ -0,0 +1,815 @@
+"""
+Nó para processamento de arquivos CSV
+"""
+import os
+import shutil
+import logging
+import time
+import pandas as pd
+import numpy as np
+from typing import Dict, Any, TypedDict, List, Optional
+from sqlalchemy.types import DateTime, Integer, Float, String, Boolean
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+import multiprocessing as mp
+
+from utils.config import UPLOADED_CSV_PATH
+from utils.object_manager import get_object_manager
+import numpy as np
+
+def analyze_numeric_column(sample_values: pd.Series) -> Dict[str, Any]:
+    """
+    Análise otimizada para detectar se coluna é numérica
+
+    Args:
+        sample_values: Amostra dos valores da coluna
+
+    Returns:
+        Dicionário com análise numérica
+    """
+    analysis = {
+        "is_numeric": False,
+        "is_integer": False,
+        "numeric_ratio": 0.0,
+        "has_decimals": False
+    }
+
+    if len(sample_values) == 0:
+        return analysis
+
+    # Converte para string e limpa valores
+    str_values = sample_values.astype(str).str.strip()
+
+    # Remove valores vazios e nulos
+    clean_values = str_values[
+        ~str_values.isin(['', 'nan', 'null', 'none', '-', 'NaN', 'NULL'])
+    ]
+
+    if len(clean_values) == 0:
+        return analysis
+
+    # Tenta conversão numérica vetorizada
+    try:
+        # Substitui vírgulas por pontos para formato brasileiro
+        numeric_values = clean_values.str.replace(',', '.', regex=False)
+
+        # Tenta conversão para float
+        converted = pd.to_numeric(numeric_values, errors='coerce')
+
+        # Conta valores válidos
+        valid_count = converted.notna().sum()
+        total_count = len(clean_values)
+
+        analysis["numeric_ratio"] = valid_count / total_count if total_count > 0 else 0
+
+        # Se mais de 80% são números válidos, considera numérico
+        if analysis["numeric_ratio"] > 0.8:
+            analysis["is_numeric"] = True
+
+            # Verifica se são inteiros
+            valid_numbers = converted.dropna()
+            if len(valid_numbers) > 0:
+                # Verifica se todos os números válidos são inteiros
+                analysis["is_integer"] = all(
+                    float(x).is_integer() for x in valid_numbers
+                    if not pd.isna(x) and abs(x) < 1e15  # Evita overflow
+                )
+                analysis["has_decimals"] = not analysis["is_integer"]
+
+    except Exception as e:
+        logging.debug(f"Erro na análise numérica: {e}")
+        analysis["is_numeric"] = False
+
+    return analysis
+
+def detect_date_format(date_string: str) -> str:
+    """
+    Detecta o formato mais provável de uma string de data
+
+    Args:
+        date_string: String para analisar
+
+    Returns:
+        'iso', 'american', 'brazilian' ou 'auto'
+    """
+    date_str = str(date_string).strip()
+
+    # Formato ISO (YYYY-MM-DD ou YYYY/MM/DD)
+    if len(date_str) >= 10 and date_str[4] in ['-', '/', '.'] and date_str[7] in ['-', '/', '.']:
+        if date_str[:4].isdigit() and int(date_str[:4]) > 1900:
+            return 'iso'
+
+    # Verifica se pode ser formato americano (MM/DD/YYYY)
+    if '/' in date_str:
+        parts = date_str.split('/')
+        if len(parts) == 3:
+            try:
+                month, day, year = int(parts[0]), int(parts[1]), int(parts[2])
+                # Se o primeiro número é > 12, provavelmente é DD/MM/YYYY
+                if month > 12:
+                    return 'brazilian'
+                # Se o segundo número é > 12, provavelmente é MM/DD/YYYY
+                elif day > 12:
+                    return 'american'
+                # Se ambos <= 12, é ambíguo, assume brasileiro por padrão
+                else:
+                    return 'brazilian'
+            except:
+                pass
+
+    # Formato brasileiro por padrão (DD/MM/YYYY, DD-MM-YYYY, DD.MM.YYYY)
+    return 'brazilian'
+
+def smart_date_conversion(date_string: str):
+    """
+    Converte string para data usando detecção inteligente de formato
+
+    Args:
+        date_string: String da data
+
+    Returns:
+        Timestamp do pandas ou levanta exceção
+    """
+    format_type = detect_date_format(date_string)
+
+    if format_type == 'iso':
+        return pd.to_datetime(date_string, errors='raise')
+    elif format_type == 'american':
+        return pd.to_datetime(date_string, format='%m/%d/%Y', errors='raise')
+    elif format_type == 'brazilian':
+        return pd.to_datetime(date_string, dayfirst=True, errors='raise')
+    else:
+        # Fallback para detecção automática
+        return pd.to_datetime(date_string, errors='raise')
+
+async def process_dates_advanced(series: pd.Series) -> pd.Series:
+    """
+    Processa datas com múltiplos formatos de forma robusta
+
+    Args:
+        series: Série pandas com datas em formato texto
+
+    Returns:
+        Série com datas convertidas para datetime
+    """
+    # Formatos de data para tentar em ordem de prioridade
+    date_formats = [
+        '%d/%m/%Y',     # 01/12/2024
+        '%d-%m-%Y',     # 01-12-2024
+        '%Y-%m-%d',     # 2024-12-01
+        '%d/%m/%y',     # 01/12/24
+        '%d-%m-%y',     # 01-12-24
+        '%Y/%m/%d',     # 2024/12/01
+        '%d.%m.%Y',     # 01.12.2024
+        '%Y.%m.%d',     # 2024.12.01
+        '%d/%m/%Y %H:%M:%S',  # 01/12/2024 14:30:00
+        '%Y-%m-%d %H:%M:%S',  # 2024-12-01 14:30:00
+    ]
+
+    result_series = pd.Series(index=series.index, dtype='datetime64[ns]')
+
+    for idx, value in series.items():
+        if pd.isna(value) or str(value).strip() in ['', 'nan', 'null', 'none', '-']:
+            result_series[idx] = pd.NaT
+            continue
+
+        value_str = str(value).strip()
+        converted = False
+
+        # Tenta conversão automática com detecção inteligente de formato
+        try:
+            result_series[idx] = smart_date_conversion(value_str)
+            converted = True
+        except:
+            pass
+
+        # Se não funcionou, tenta formatos específicos
+        if not converted:
+            for fmt in date_formats:
+                try:
+                    result_series[idx] = pd.to_datetime(value_str, format=fmt, errors='raise')
+                    converted = True
+                    break
+                except:
+                    continue
+
+        # Se ainda não converteu, marca como NaT
+        if not converted:
+            result_series[idx] = pd.NaT
+            logging.warning(f"Não foi possível converter '{value_str}' para data")
+
+    return result_series
+
+class CSVProcessingState(TypedDict):
+    """Estado para processamento de CSV"""
+    file_path: str
+    success: bool
+    message: str
+    csv_data_sample: dict
+    column_info: dict
+    processing_stats: dict
+
+async def detect_column_types(df: pd.DataFrame, sample_size: int = 1000) -> Dict[str, Any]:
+    """
+    Detecta automaticamente os tipos de colunas de forma genérica e otimizada
+
+    Args:
+        df: DataFrame do pandas
+        sample_size: Número de linhas para amostragem (otimização)
+
+    Returns:
+        Dicionário com informações dos tipos detectados
+    """
+    column_info = {
+        "detected_types": {},
+        "sql_types": {},
+        "date_columns": [],
+        "numeric_columns": [],
+        "text_columns": [],
+        "processing_rules": {}
+    }
+
+    # Usa amostra para otimizar performance em datasets grandes
+    sample_df = df.sample(n=min(sample_size, len(df)), random_state=42) if len(df) > sample_size else df
+    logging.info(f"[OPTIMIZATION] Usando amostra de {len(sample_df)} linhas para detecção de tipos")
+
+    for col in df.columns:
+        # Detecta tipo original
+        original_type = str(df[col].dtype)
+        column_info["detected_types"][col] = original_type
+
+        # Usa amostra para análise
+        sample_col = sample_df[col] if col in sample_df.columns else df[col]
+        
+        # Detecta números já convertidos pelo pandas
+        if sample_col.dtype in ['int64', 'Int64', 'float64', 'Float64']:
+            if 'int' in str(sample_col.dtype).lower():
+                column_info["numeric_columns"].append(col)
+                column_info["sql_types"][col] = Integer()
+                column_info["processing_rules"][col] = "keep_as_int"
+            else:
+                column_info["numeric_columns"].append(col)
+                column_info["sql_types"][col] = Float()
+                column_info["processing_rules"][col] = "keep_as_float"
+            continue
+
+        # Tenta detectar datas de forma mais robusta
+        if sample_col.dtype == 'object':
+            # Tenta detectar datas com múltiplos formatos
+            sample_values = sample_col.dropna().head(20)
+            date_success_count = 0
+
+            # Formatos de data comuns para testar
+            date_formats = [
+                '%d/%m/%Y',     # 01/12/2024
+                '%d-%m-%Y',     # 01-12-2024
+                '%Y-%m-%d',     # 2024-12-01
+                '%d/%m/%y',     # 01/12/24
+                '%d-%m-%y',     # 01-12-24
+                '%Y/%m/%d',     # 2024/12/01
+                '%d.%m.%Y',     # 01.12.2024
+                '%Y.%m.%d',     # 2024.12.01
+            ]
+
+            for val in sample_values:
+                val_str = str(val).strip()
+                if not val_str or val_str.lower() in ['nan', 'null', 'none', '-']:
+                    continue
+
+                # Tenta conversão automática com detecção inteligente
+                try:
+                    smart_date_conversion(val_str)
+                    date_success_count += 1
+                    continue
+                except:
+                    pass
+
+                # Tenta formatos específicos
+                for fmt in date_formats:
+                    try:
+                        pd.to_datetime(val_str, format=fmt, errors='raise')
+                        date_success_count += 1
+                        break
+                    except:
+                        continue
+
+            # Se mais de 70% dos valores são datas válidas, considera como coluna de data
+            if len(sample_values) > 0 and date_success_count / len(sample_values) > 0.7:
+                column_info["date_columns"].append(col)
+                column_info["sql_types"][col] = DateTime()
+                column_info["processing_rules"][col] = "parse_dates_advanced"
+                continue
+        
+        # Tenta detectar números em colunas de texto (otimizado)
+        elif sample_col.dtype == 'object':
+            # Análise otimizada de números em texto
+            sample_values = sample_col.dropna().head(50)  # Aumenta amostra para melhor precisão
+
+            if len(sample_values) == 0:
+                column_info["text_columns"].append(col)
+                column_info["sql_types"][col] = String()
+                column_info["processing_rules"][col] = "keep_as_text"
+                continue
+
+            # Análise vetorizada para performance
+            numeric_analysis = analyze_numeric_column(sample_values)
+
+            if numeric_analysis["is_numeric"]:
+                if numeric_analysis["is_integer"]:
+                    column_info["numeric_columns"].append(col)
+                    column_info["sql_types"][col] = Integer()
+                    column_info["processing_rules"][col] = "convert_text_to_int_safe"
+                else:
+                    column_info["numeric_columns"].append(col)
+                    column_info["sql_types"][col] = Float()
+                    column_info["processing_rules"][col] = "convert_text_to_float_safe"
+            else:
+                # Mantém como texto
+                column_info["text_columns"].append(col)
+                column_info["sql_types"][col] = String()
+                column_info["processing_rules"][col] = "keep_as_text"
+        
+        # Tenta detectar números em colunas de texto
+        elif df[col].dtype == 'object':
+            # Verifica se pode ser convertido para número
+            sample_values = df[col].dropna().head(20)
+            numeric_count = 0
+            
+            for val in sample_values:
+                try:
+                    # Remove caracteres comuns e tenta converter
+                    clean_val = str(val).replace(',', '.').replace('-', '').strip()
+                    if clean_val:
+                        float(clean_val)
+                        numeric_count += 1
+                except:
+                    pass
+            
+            # Se mais de 70% são números, trata como numérico
+            if len(sample_values) > 0 and numeric_count / len(sample_values) > 0.7:
+                # Verifica se são inteiros ou floats
+                has_decimal = any('.' in str(val) or ',' in str(val) for val in sample_values)
+                if has_decimal:
+                    column_info["numeric_columns"].append(col)
+                    column_info["sql_types"][col] = Float()
+                    column_info["processing_rules"][col] = "convert_text_to_float"
+                else:
+                    column_info["numeric_columns"].append(col)
+                    column_info["sql_types"][col] = Integer()
+                    column_info["processing_rules"][col] = "convert_text_to_int"
+            else:
+                # Mantém como texto
+                column_info["text_columns"].append(col)
+                column_info["sql_types"][col] = String()
+                column_info["processing_rules"][col] = "keep_as_text"
+        else:
+            # Outros tipos mantém como texto
+            column_info["text_columns"].append(col)
+            column_info["sql_types"][col] = String()
+            column_info["processing_rules"][col] = "keep_as_text"
+    
+    return column_info
+
+async def process_dataframe_generic(df: pd.DataFrame, column_info: Dict[str, Any]) -> pd.DataFrame:
+    """
+    Processa DataFrame com OTIMIZAÇÕES EXTREMAS para performance máxima
+
+    Args:
+        df: DataFrame original
+        column_info: Informações dos tipos detectados
+
+    Returns:
+        DataFrame processado
+    """
+    logging.info(f"[ULTRA_OPTIMIZATION] Iniciando processamento ULTRA-OTIMIZADO de {len(df)} linhas")
+    start_time = time.time()
+
+    # OTIMIZAÇÃO 1: Evita cópia desnecessária - modifica in-place quando possível
+    processed_df = df
+
+    # OTIMIZAÇÃO 2: Agrupa colunas por tipo de processamento
+    processing_groups = {
+        'dates': [],
+        'keep_numeric': [],
+        'convert_numeric': [],
+        'text': []
+    }
+
+    for col, rule in column_info["processing_rules"].items():
+        if col not in processed_df.columns:
+            continue
+
+        if 'date' in rule:
+            processing_groups['dates'].append((col, rule))
+        elif 'keep_as' in rule:
+            processing_groups['keep_numeric'].append((col, rule))
+        elif 'convert' in rule:
+            processing_groups['convert_numeric'].append((col, rule))
+        else:
+            processing_groups['text'].append((col, rule))
+
+    # OTIMIZAÇÃO 3: Processamento paralelo por grupos
+    await process_groups_parallel(processed_df, processing_groups)
+
+    total_time = time.time() - start_time
+    logging.info(f"[ULTRA_OPTIMIZATION] Processamento ULTRA-OTIMIZADO concluído em {total_time:.2f}s")
+
+    return processed_df
+
+async def process_groups_parallel(df: pd.DataFrame, groups: Dict[str, List]):
+    """
+    Processa grupos de colunas em paralelo para máxima performance
+    """
+    tasks = []
+
+    # Processa cada grupo
+    for group_name, columns in groups.items():
+        if not columns:
+            continue
+
+        if group_name == 'dates':
+            tasks.append(process_date_columns_batch(df, columns))
+        elif group_name == 'keep_numeric':
+            tasks.append(process_keep_numeric_batch(df, columns))
+        elif group_name == 'convert_numeric':
+            tasks.append(process_convert_numeric_batch(df, columns))
+        # text não precisa processamento
+
+    # Executa todos os grupos em paralelo
+    if tasks:
+        import asyncio
+        await asyncio.gather(*tasks)
+
+async def process_date_columns_batch(df: pd.DataFrame, date_columns: List[tuple]):
+    """Processa colunas de data em lote"""
+    for col, rule in date_columns:
+        try:
+            if rule == "parse_dates_advanced":
+                # OTIMIZAÇÃO: Processamento vetorizado de datas
+                df[col] = process_dates_vectorized(df[col])
+            else:
+                df[col] = pd.to_datetime(df[col], dayfirst=True, errors='coerce')
+        except Exception as e:
+            logging.warning(f"Erro ao processar data {col}: {e}")
+
+async def process_keep_numeric_batch(df: pd.DataFrame, numeric_columns: List[tuple]):
+    """Processa colunas numéricas que já estão no tipo correto"""
+    for col, rule in numeric_columns:
+        try:
+            if rule == "keep_as_int" and df[col].dtype != 'Int64':
+                df[col] = df[col].astype("Int64")
+            elif rule == "keep_as_float" and df[col].dtype != 'float64':
+                df[col] = df[col].astype("float64")
+        except Exception as e:
+            logging.warning(f"Erro ao manter tipo {col}: {e}")
+
+async def process_convert_numeric_batch(df: pd.DataFrame, convert_columns: List[tuple]):
+    """Processa conversões numéricas em lote com máxima otimização"""
+    for col, rule in convert_columns:
+        try:
+            if rule == "convert_text_to_int_safe":
+                df[col] = convert_to_int_ultra_optimized(df[col])
+            elif rule == "convert_text_to_float_safe":
+                df[col] = convert_to_float_ultra_optimized(df[col])
+        except Exception as e:
+            logging.warning(f"Erro ao converter {col}: {e}")
+            if rule == "parse_dates":
+                processed_df[col] = pd.to_datetime(
+                    processed_df[col],
+                    dayfirst=True,
+                    errors='coerce'
+                )
+
+            elif rule == "parse_dates_advanced":
+                # Processamento avançado de datas com múltiplos formatos
+                processed_df[col] = await process_dates_advanced(processed_df[col])
+                
+            elif rule == "keep_as_int":
+                # Já é inteiro, apenas garante tipo correto
+                if processed_df[col].dtype != 'Int64':
+                    processed_df[col] = processed_df[col].astype("Int64")
+
+            elif rule == "keep_as_float":
+                # Já é float, apenas garante tipo correto
+                if processed_df[col].dtype != 'float64':
+                    processed_df[col] = processed_df[col].astype("float64")
+
+            elif rule == "convert_text_to_int_safe":
+                # Conversão otimizada e segura para inteiros
+                processed_df[col] = convert_to_int_optimized(processed_df[col])
+
+            elif rule == "convert_text_to_float_safe":
+                # Conversão otimizada e segura para floats
+                processed_df[col] = convert_to_float_optimized(processed_df[col])
+                
+            elif rule == "keep_as_text":
+                # Mantém como texto, apenas garante que é string
+                processed_df[col] = processed_df[col].astype(str)
+                
+        except Exception as e:
+            logging.warning(f"Erro ao processar coluna {col} com regra {rule}: {e}")
+            # Em caso de erro, mantém coluna original
+            continue
+
+        col_time = time.time() - col_start_time
+        logging.debug(f"[OPTIMIZATION] Coluna {col} processada em {col_time:.2f}s")
+
+    total_time = time.time() - start_time
+    logging.info(f"[OPTIMIZATION] Processamento concluído em {total_time:.2f}s")
+
+    return processed_df
+
+def convert_to_int_optimized(series: pd.Series) -> pd.Series:
+    """
+    Conversão otimizada para inteiros
+
+    Args:
+        series: Série para converter
+
+    Returns:
+        Série convertida para Int64
+    """
+    try:
+        # Operações vetorizadas para performance
+        cleaned = series.astype(str).str.strip()
+
+        # Remove valores inválidos
+        cleaned = cleaned.replace(['', 'nan', 'null', 'none', '-', 'NaN', 'NULL'], np.nan)
+
+        # Substitui vírgulas por pontos
+        cleaned = cleaned.str.replace(',', '.', regex=False)
+
+        # Converte para numérico
+        numeric = pd.to_numeric(cleaned, errors='coerce')
+
+        # Verifica se pode ser convertido para inteiro sem perda
+        # Só converte se todos os valores válidos são inteiros
+        valid_mask = numeric.notna()
+        if valid_mask.any():
+            valid_numbers = numeric[valid_mask]
+            # Verifica se são inteiros (sem parte decimal significativa)
+            is_integer_mask = np.abs(valid_numbers - np.round(valid_numbers)) < 1e-10
+
+            if is_integer_mask.all():
+                # Todos são inteiros, pode converter
+                result = numeric.round().astype("Int64")
+            else:
+                # Tem decimais, mantém como float mas avisa
+                logging.warning(f"Coluna contém decimais, mantendo como float")
+                result = numeric.astype("Float64")
+        else:
+            # Nenhum valor válido
+            result = pd.Series([pd.NA] * len(series), dtype="Int64")
+
+        return result
+
+    except Exception as e:
+        logging.error(f"Erro na conversão otimizada para int: {e}")
+        return series
+
+def convert_to_float_optimized(series: pd.Series) -> pd.Series:
+    """
+    Conversão otimizada para floats
+
+    Args:
+        series: Série para converter
+
+    Returns:
+        Série convertida para float64
+    """
+    try:
+        # Operações vetorizadas para performance
+        cleaned = series.astype(str).str.strip()
+
+        # Remove valores inválidos
+        cleaned = cleaned.replace(['', 'nan', 'null', 'none', '-', 'NaN', 'NULL'], np.nan)
+
+        # Substitui vírgulas por pontos (formato brasileiro)
+        cleaned = cleaned.str.replace(',', '.', regex=False)
+
+        # Converte para numérico
+        result = pd.to_numeric(cleaned, errors='coerce')
+
+        return result
+
+    except Exception as e:
+        logging.error(f"Erro na conversão otimizada para float: {e}")
+        return series
+
+def convert_to_int_ultra_optimized(series: pd.Series) -> pd.Series:
+    """
+    Conversão ULTRA-OTIMIZADA para inteiros usando NumPy puro
+    """
+    try:
+        # OTIMIZAÇÃO EXTREMA: Usa NumPy diretamente
+        values = series.values
+
+        # Se já é numérico, converte diretamente
+        if pd.api.types.is_numeric_dtype(series):
+            return pd.Series(values, dtype="Int64")
+
+        # Para strings, usa operações vetorizadas do NumPy
+        str_values = np.asarray(series.astype(str))
+
+        # Máscara para valores válidos
+        valid_mask = ~np.isin(str_values, ['', 'nan', 'null', 'none', '-', 'NaN', 'NULL'])
+
+        # Inicializa resultado
+        result = np.full(len(series), pd.NA, dtype=object)
+
+        if valid_mask.any():
+            valid_values = str_values[valid_mask]
+
+            # Remove vírgulas e converte
+            cleaned = np.char.replace(valid_values, ',', '.')
+
+            # Conversão vetorizada
+            try:
+                numeric_values = pd.to_numeric(cleaned, errors='coerce')
+                # Só converte se são realmente inteiros
+                int_mask = np.abs(numeric_values - np.round(numeric_values)) < 1e-10
+                int_values = np.round(numeric_values[int_mask]).astype('Int64')
+
+                # Atribui valores convertidos
+                valid_indices = np.where(valid_mask)[0]
+                int_indices = valid_indices[int_mask]
+                result[int_indices] = int_values
+
+            except Exception:
+                pass
+
+        return pd.Series(result, dtype="Int64")
+
+    except Exception as e:
+        logging.error(f"Erro na conversão ultra-otimizada para int: {e}")
+        return series
+
+def convert_to_float_ultra_optimized(series: pd.Series) -> pd.Series:
+    """
+    Conversão ULTRA-OTIMIZADA para floats usando NumPy puro
+    """
+    try:
+        # OTIMIZAÇÃO EXTREMA: Usa NumPy diretamente
+        values = series.values
+
+        # Se já é numérico, retorna diretamente
+        if pd.api.types.is_numeric_dtype(series):
+            return series.astype('float64')
+
+        # Para strings, usa operações vetorizadas do NumPy
+        str_values = np.asarray(series.astype(str))
+
+        # Máscara para valores válidos
+        valid_mask = ~np.isin(str_values, ['', 'nan', 'null', 'none', '-', 'NaN', 'NULL'])
+
+        # Inicializa resultado
+        result = np.full(len(series), np.nan, dtype='float64')
+
+        if valid_mask.any():
+            valid_values = str_values[valid_mask]
+
+            # Remove vírgulas (formato brasileiro)
+            cleaned = np.char.replace(valid_values, ',', '.')
+
+            # Conversão vetorizada ultra-rápida
+            numeric_values = pd.to_numeric(cleaned, errors='coerce')
+            result[valid_mask] = numeric_values
+
+        return pd.Series(result, dtype='float64')
+
+    except Exception as e:
+        logging.error(f"Erro na conversão ultra-otimizada para float: {e}")
+        return series
+
+def process_dates_vectorized(series: pd.Series) -> pd.Series:
+    """
+    Processamento vetorizado ULTRA-OTIMIZADO de datas
+    """
+    try:
+        # OTIMIZAÇÃO: Tenta conversão direta primeiro
+        try:
+            return pd.to_datetime(series, dayfirst=True, errors='coerce')
+        except:
+            pass
+
+        # Se falhou, usa abordagem mais robusta mas ainda otimizada
+        str_values = series.astype(str)
+
+        # Detecta formato mais comum na amostra
+        sample = str_values.dropna().head(100)
+        if len(sample) > 0:
+            first_val = sample.iloc[0]
+
+            # Detecta formato baseado no primeiro valor
+            if len(first_val) >= 10 and first_val[4] in ['-', '/']:
+                # Formato ISO
+                return pd.to_datetime(series, errors='coerce')
+            else:
+                # Formato brasileiro
+                return pd.to_datetime(series, dayfirst=True, errors='coerce')
+
+        return pd.to_datetime(series, errors='coerce')
+
+    except Exception as e:
+        logging.error(f"Erro no processamento vetorizado de datas: {e}")
+        return series
+
+async def csv_processing_node(state: CSVProcessingState) -> CSVProcessingState:
+    """
+    Nó principal para processamento de CSV
+    
+    Args:
+        state: Estado do processamento CSV
+        
+    Returns:
+        Estado atualizado
+    """
+    try:
+        file_path = state["file_path"]
+        
+        # Copia arquivo para diretório de upload
+        shutil.copy(file_path, UPLOADED_CSV_PATH)
+        logging.info(f"[CSV_PROCESSING] Arquivo copiado para: {UPLOADED_CSV_PATH}")
+        
+        # OTIMIZAÇÃO EXTREMA: Leitura de CSV ultra-otimizada
+        separators = [';', ',', '\t', '|']
+        df = None
+        used_separator = None
+
+        # Detecta separador com amostra mínima
+        for sep in separators:
+            try:
+                test_df = pd.read_csv(file_path, sep=sep, nrows=3, engine='c')  # Engine C é mais rápido
+                if len(test_df.columns) > 1:
+                    # OTIMIZAÇÃO: Lê com configurações de performance máxima
+                    df = pd.read_csv(
+                        file_path,
+                        sep=sep,
+                        encoding='utf-8',
+                        on_bad_lines="skip",
+                        engine='c',  # Engine C para máxima performance
+                        low_memory=False,  # Evita warnings de tipos mistos
+                        dtype=str  # Lê tudo como string primeiro (mais rápido)
+                    )
+                    used_separator = sep
+                    break
+            except:
+                continue
+        
+        if df is None:
+            raise ValueError("Não foi possível detectar o formato do CSV")
+        
+        logging.info(f"[CSV_PROCESSING] CSV lido com separador '{used_separator}', {len(df)} linhas, {len(df.columns)} colunas")
+        
+        # Detecta tipos de colunas automaticamente
+        column_info = await detect_column_types(df)
+        
+        # Processa DataFrame
+        processed_df = await process_dataframe_generic(df, column_info)
+        
+        # Estatísticas do processamento
+        processing_stats = {
+            "original_rows": len(df),
+            "processed_rows": len(processed_df),
+            "original_columns": len(df.columns),
+            "processed_columns": len(processed_df.columns),
+            "separator_used": used_separator,
+            "date_columns_detected": len(column_info["date_columns"]),
+            "numeric_columns_detected": len(column_info["numeric_columns"]),
+            "text_columns_detected": len(column_info["text_columns"])
+        }
+        
+        # Amostra dos dados para o estado
+        csv_data_sample = {
+            "head": processed_df.head(5).to_dict(),
+            "dtypes": processed_df.dtypes.astype(str).to_dict(),
+            "columns": list(processed_df.columns)
+        }
+        
+        # Armazena DataFrame processado no gerenciador de objetos
+        obj_manager = get_object_manager()
+        df_id = obj_manager.store_object(processed_df, "processed_dataframe")
+        
+        # Atualiza estado
+        state.update({
+            "success": True,
+            "message": f"✅ CSV processado com sucesso! {processing_stats['processed_rows']} linhas, {processing_stats['processed_columns']} colunas",
+            "csv_data_sample": csv_data_sample,
+            "column_info": column_info,
+            "processing_stats": processing_stats,
+            "dataframe_id": df_id
+        })
+        
+        logging.info(f"[CSV_PROCESSING] Processamento concluído: {processing_stats}")
+        
+    except Exception as e:
+        error_msg = f"❌ Erro ao processar CSV: {e}"
+        logging.error(f"[CSV_PROCESSING] {error_msg}")
+        state.update({
+            "success": False,
+            "message": error_msg,
+            "csv_data_sample": {},
+            "column_info": {},
+            "processing_stats": {}
+        })
+    
+    return state

nodes/custom_nodes.py

@@ -0,0 +1,297 @@
+"""
+Nós personalizados para funcionalidades específicas
+"""
+import os
+import shutil
+import logging
+from typing import Dict, Any, TypedDict
+
+from utils.database import create_sql_database
+from utils.config import UPLOADED_CSV_PATH, SQL_DB_PATH, DEFAULT_CSV_PATH
+from agents.sql_agent import SQLAgentManager
+from nodes.csv_processing_node import csv_processing_node
+from nodes.database_node import create_database_from_dataframe_node, load_existing_database_node
+
+class FileUploadState(TypedDict):
+    """Estado para upload de arquivos"""
+    file_path: str
+    success: bool
+    message: str
+    engine: Any
+    sql_agent: SQLAgentManager
+    cache_manager: Any
+
+class ResetState(TypedDict):
+    """Estado para reset do sistema"""
+    success: bool
+    message: str
+    engine: Any
+    sql_agent: SQLAgentManager
+    cache_manager: Any
+
+async def handle_csv_upload_node(state: FileUploadState) -> FileUploadState:
+    """
+    Nó para processar upload de CSV
+    
+    Args:
+        state: Estado do upload
+        
+    Returns:
+        Estado atualizado
+    """
+    try:
+        file_path = state["file_path"]
+        
+        # Etapa 1: Processa CSV usando nova arquitetura
+        csv_state = {
+            "file_path": file_path,
+            "success": False,
+            "message": "",
+            "csv_data_sample": {},
+            "column_info": {},
+            "processing_stats": {}
+        }
+
+        csv_result = await csv_processing_node(csv_state)
+        if not csv_result["success"]:
+            raise Exception(csv_result["message"])
+
+        # Etapa 2: Cria banco de dados
+        db_result = await create_database_from_dataframe_node(csv_result)
+        if not db_result["success"]:
+            raise Exception(db_result["message"])
+
+        # Recupera objetos criados
+        from utils.object_manager import get_object_manager
+        obj_manager = get_object_manager()
+
+        engine = obj_manager.get_engine(db_result["engine_id"])
+        db = obj_manager.get_object(db_result["db_id"])
+
+        logging.info("[UPLOAD] Novo banco carregado e DB atualizado usando nova arquitetura.")
+
+        # Recria agente SQL
+        sql_agent = SQLAgentManager(db)
+        
+        # Limpa cache
+        state["cache_manager"].clear_cache()
+        
+        # Atualiza estado
+        state["engine"] = engine
+        state["sql_agent"] = sql_agent
+        state["success"] = True
+        state["message"] = "✅ CSV carregado com sucesso!"
+        
+        logging.info("[UPLOAD] Novo banco carregado e agente recriado. Cache limpo.")
+        
+    except Exception as e:
+        error_msg = f"❌ Erro ao processar CSV: {e}"
+        logging.error(f"[ERRO] Falha ao processar novo CSV: {e}")
+        state["success"] = False
+        state["message"] = error_msg
+    
+    return state
+
+async def reset_system_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para resetar o sistema ao estado inicial
+
+    Args:
+        state: Estado do reset
+
+    Returns:
+        Estado atualizado
+    """
+    try:
+        from utils.object_manager import get_object_manager
+        from agents.sql_agent import SQLAgentManager
+
+        obj_manager = get_object_manager()
+
+        # Remove CSV personalizado se existir
+        if os.path.exists(UPLOADED_CSV_PATH):
+            os.remove(UPLOADED_CSV_PATH)
+            logging.info("[RESET] CSV personalizado removido.")
+
+        # Recria banco com CSV padrão usando nova arquitetura
+        csv_state = {
+            "file_path": DEFAULT_CSV_PATH,
+            "success": False,
+            "message": "",
+            "csv_data_sample": {},
+            "column_info": {},
+            "processing_stats": {}
+        }
+
+        csv_result = await csv_processing_node(csv_state)
+        if not csv_result["success"]:
+            raise Exception(csv_result["message"])
+
+        # Cria banco de dados
+        db_result = await create_database_from_dataframe_node(csv_result)
+        if not db_result["success"]:
+            raise Exception(db_result["message"])
+
+        # Recupera objetos criados
+        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)
+
+        # Atualiza objetos no gerenciador
+        engine_id = obj_manager.store_engine(engine)
+        agent_id = obj_manager.store_sql_agent(sql_agent)
+
+        # Limpa cache se disponível
+        cache_id = state.get("cache_id")
+        if cache_id:
+            cache_manager = obj_manager.get_cache_manager(cache_id)
+            if cache_manager:
+                cache_manager.clear_cache()
+
+        # Atualiza estado
+        state.update({
+            "engine_id": engine_id,
+            "agent_id": agent_id,
+            "success": True,
+            "message": "🔄 Sistema resetado para o estado inicial."
+        })
+
+        logging.info("[RESET] Sistema resetado com sucesso.")
+
+    except Exception as e:
+        error_msg = f"❌ Erro ao resetar: {e}"
+        logging.error(f"[ERRO] Falha ao resetar sistema: {e}")
+        state.update({
+            "success": False,
+            "message": error_msg
+        })
+
+    return state
+
+async def validate_system_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para validar o estado do sistema
+    
+    Args:
+        state: Estado atual do sistema
+        
+    Returns:
+        Estado com informações de validação
+    """
+    validation_results = {
+        "database_valid": False,
+        "agent_valid": False,
+        "cache_valid": False,
+        "overall_valid": False
+    }
+    
+    try:
+        # Valida banco de dados
+        if state.get("engine"):
+            from utils.database import validate_database
+            validation_results["database_valid"] = validate_database(state["engine"])
+        
+        # Valida agente SQL
+        if state.get("sql_agent"):
+            validation_results["agent_valid"] = state["sql_agent"].validate_agent()
+        
+        # Valida cache
+        if state.get("cache_manager"):
+            validation_results["cache_valid"] = True  # Cache sempre válido se existe
+        
+        # Validação geral
+        validation_results["overall_valid"] = all([
+            validation_results["database_valid"],
+            validation_results["agent_valid"],
+            validation_results["cache_valid"]
+        ])
+        
+        state["validation"] = validation_results
+        logging.info(f"[VALIDATION] Sistema válido: {validation_results['overall_valid']}")
+        
+    except Exception as e:
+        logging.error(f"[VALIDATION] Erro na validação: {e}")
+        state["validation"] = validation_results
+    
+    return state
+
+async def get_system_info_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para obter informações do sistema
+    
+    Args:
+        state: Estado atual do sistema
+        
+    Returns:
+        Estado com informações do sistema
+    """
+    system_info = {
+        "csv_active": None,
+        "database_path": SQL_DB_PATH,
+        "agent_info": None,
+        "cache_stats": None
+    }
+    
+    try:
+        # Informações do CSV ativo
+        from utils.config import get_active_csv_path
+        system_info["csv_active"] = get_active_csv_path()
+        
+        # Informações do agente
+        if state.get("sql_agent"):
+            system_info["agent_info"] = state["sql_agent"].get_agent_info()
+        
+        # Estatísticas do cache
+        if state.get("cache_manager"):
+            cache_manager = state["cache_manager"]
+            system_info["cache_stats"] = {
+                "cached_queries": len(cache_manager.query_cache),
+                "history_entries": len(cache_manager.history_log),
+                "recent_history_size": len(cache_manager.recent_history)
+            }
+        
+        state["system_info"] = system_info
+        logging.info("[SYSTEM_INFO] Informações do sistema coletadas")
+        
+    except Exception as e:
+        logging.error(f"[SYSTEM_INFO] Erro ao coletar informações: {e}")
+        state["system_info"] = system_info
+    
+    return state
+
+class CustomNodeManager:
+    """
+    Gerenciador dos nós personalizados
+    """
+    
+    def __init__(self):
+        self.node_functions = {
+            "csv_upload": handle_csv_upload_node,
+            "system_reset": reset_system_node,
+            "system_validation": validate_system_node,
+            "system_info": get_system_info_node
+        }
+    
+    def get_node_function(self, node_name: str):
+        """Retorna função do nó pelo nome"""
+        return self.node_functions.get(node_name)
+    
+    async def execute_node(self, node_name: str, state: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Executa um nó específico
+        
+        Args:
+            node_name: Nome do nó
+            state: Estado atual
+            
+        Returns:
+            Estado atualizado
+        """
+        node_function = self.get_node_function(node_name)
+        if node_function:
+            return await node_function(state)
+        else:
+            logging.error(f"Nó não encontrado: {node_name}")
+            return state

nodes/database_node.py

@@ -0,0 +1,226 @@
+"""
+Nó para operações de banco de dados
+"""
+import os
+import logging
+import pandas as pd
+from typing import Dict, Any, TypedDict, Optional
+from sqlalchemy import create_engine
+
+from utils.config import SQL_DB_PATH
+from utils.database import create_sql_database, validate_database
+from utils.object_manager import get_object_manager
+
+class DatabaseState(TypedDict):
+    """Estado para operações de banco de dados"""
+    success: bool
+    message: str
+    database_info: dict
+    engine_id: str
+    db_id: str
+
+async def create_database_from_dataframe_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para criar banco de dados a partir de DataFrame processado
+    
+    Args:
+        state: Estado contendo informações do DataFrame processado
+        
+    Returns:
+        Estado atualizado com informações do banco
+    """
+    try:
+        obj_manager = get_object_manager()
+        
+        # Recupera DataFrame processado
+        df_id = state.get("dataframe_id")
+        if not df_id:
+            raise ValueError("ID do DataFrame não encontrado no estado")
+        
+        processed_df = obj_manager.get_object(df_id)
+        if processed_df is None:
+            raise ValueError("DataFrame processado não encontrado")
+        
+        # Recupera informações das colunas
+        column_info = state.get("column_info", {})
+        sql_types = column_info.get("sql_types", {})
+        
+        # Cria engine do banco
+        engine = create_engine(f"sqlite:///{SQL_DB_PATH}")
+        
+        # Salva DataFrame no banco
+        processed_df.to_sql(
+            "tabela", 
+            engine, 
+            index=False, 
+            if_exists="replace", 
+            dtype=sql_types
+        )
+        
+        logging.info(f"[DATABASE] Banco criado com {len(processed_df)} registros")
+        
+        # Cria objeto SQLDatabase do LangChain
+        db = create_sql_database(engine)
+        
+        # Valida banco
+        is_valid = validate_database(engine)
+        
+        # Armazena objetos no gerenciador
+        engine_id = obj_manager.store_engine(engine)
+        db_id = obj_manager.store_database(db)
+        
+        # Informações do banco
+        database_info = {
+            "path": SQL_DB_PATH,
+            "table_name": "tabela",
+            "total_records": len(processed_df),
+            "columns": list(processed_df.columns),
+            "column_types": {col: str(dtype) for col, dtype in processed_df.dtypes.items()},
+            "is_valid": is_valid,
+            "sql_types_used": {col: str(sql_type) for col, sql_type in sql_types.items()}
+        }
+        
+        # Atualiza estado
+        state.update({
+            "success": True,
+            "message": f"✅ Banco de dados criado com sucesso! {len(processed_df)} registros salvos",
+            "database_info": database_info,
+            "engine_id": engine_id,
+            "db_id": db_id
+        })
+        
+        logging.info(f"[DATABASE] Banco criado e validado: {database_info}")
+        
+    except Exception as e:
+        error_msg = f"❌ Erro ao criar banco de dados: {e}"
+        logging.error(f"[DATABASE] {error_msg}")
+        state.update({
+            "success": False,
+            "message": error_msg,
+            "database_info": {},
+            "engine_id": "",
+            "db_id": ""
+        })
+    
+    return state
+
+async def load_existing_database_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para carregar banco de dados existente
+    
+    Args:
+        state: Estado atual
+        
+    Returns:
+        Estado atualizado com informações do banco existente
+    """
+    try:
+        if not os.path.exists(SQL_DB_PATH):
+            raise ValueError("Banco de dados não encontrado")
+        
+        # Cria engine
+        engine = create_engine(f"sqlite:///{SQL_DB_PATH}")
+        
+        # Cria objeto SQLDatabase
+        db = create_sql_database(engine)
+        
+        # Valida banco
+        is_valid = validate_database(engine)
+        
+        # Obtém informações do banco
+        try:
+            sample_df = pd.read_sql_query("SELECT * FROM tabela LIMIT 5", engine)
+            total_records_df = pd.read_sql_query("SELECT COUNT(*) as count FROM tabela", engine)
+            total_records = total_records_df.iloc[0]['count']
+            
+            database_info = {
+                "path": SQL_DB_PATH,
+                "table_name": "tabela",
+                "total_records": total_records,
+                "columns": list(sample_df.columns),
+                "column_types": {col: str(dtype) for col, dtype in sample_df.dtypes.items()},
+                "is_valid": is_valid,
+                "sample_data": sample_df.head(3).to_dict()
+            }
+        except Exception as e:
+            logging.warning(f"Erro ao obter informações detalhadas do banco: {e}")
+            database_info = {
+                "path": SQL_DB_PATH,
+                "table_name": "tabela",
+                "is_valid": is_valid,
+                "error": str(e)
+            }
+        
+        # Armazena objetos no gerenciador
+        obj_manager = get_object_manager()
+        engine_id = obj_manager.store_engine(engine)
+        db_id = obj_manager.store_database(db)
+        
+        # Atualiza estado
+        state.update({
+            "success": True,
+            "message": "✅ Banco de dados existente carregado com sucesso",
+            "database_info": database_info,
+            "engine_id": engine_id,
+            "db_id": db_id
+        })
+        
+        logging.info(f"[DATABASE] Banco existente carregado: {database_info}")
+        
+    except Exception as e:
+        error_msg = f"❌ Erro ao carregar banco existente: {e}"
+        logging.error(f"[DATABASE] {error_msg}")
+        state.update({
+            "success": False,
+            "message": error_msg,
+            "database_info": {},
+            "engine_id": "",
+            "db_id": ""
+        })
+    
+    return state
+
+async def get_database_sample_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para obter amostra dos dados do banco
+    
+    Args:
+        state: Estado contendo ID da engine
+        
+    Returns:
+        Estado atualizado com amostra dos dados
+    """
+    try:
+        obj_manager = get_object_manager()
+        
+        # Recupera engine
+        engine_id = state.get("engine_id")
+        if not engine_id:
+            raise ValueError("ID da engine não encontrado")
+        
+        engine = obj_manager.get_engine(engine_id)
+        if not engine:
+            raise ValueError("Engine não encontrada")
+        
+        # Obtém amostra dos dados
+        sample_df = pd.read_sql_query("SELECT * FROM tabela LIMIT 10", engine)
+        
+        # Converte para formato serializável
+        db_sample_dict = {
+            "data": sample_df.to_dict('records'),
+            "columns": list(sample_df.columns),
+            "dtypes": sample_df.dtypes.astype(str).to_dict(),
+            "shape": sample_df.shape
+        }
+        
+        state["db_sample_dict"] = db_sample_dict
+        
+        logging.info(f"[DATABASE] Amostra obtida: {sample_df.shape[0]} registros")
+        
+    except Exception as e:
+        error_msg = f"Erro ao obter amostra do banco: {e}"
+        logging.error(f"[DATABASE] {error_msg}")
+        state["db_sample_dict"] = {}
+        state["error"] = error_msg
+    
+    return state

nodes/graph_generation_node.py

@@ -0,0 +1,1015 @@
+"""
+Nó para geração de gráficos
+"""
+import io
+import logging
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+from PIL import Image
+from typing import Dict, Any, Optional
+
+from utils.object_manager import get_object_manager
+
+async def graph_generation_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para geração de gráficos baseado no tipo selecionado
+    
+    Args:
+        state: Estado atual do agente
+        
+    Returns:
+        Estado atualizado com gráfico gerado
+    """
+    try:
+        logging.info("[GRAPH_GENERATION] Iniciando geração de gráfico")
+        
+        # Verifica se há tipo de gráfico selecionado
+        graph_type = state.get("graph_type")
+        if not graph_type:
+            logging.info("[GRAPH_GENERATION] Nenhum tipo de gráfico selecionado, pulando geração")
+            return state
+        
+        # Verifica se há erro anterior
+        if state.get("graph_error"):
+            logging.info("[GRAPH_GENERATION] Erro anterior detectado, pulando geração")
+            return state
+        
+        # Recupera dados do gráfico
+        graph_data = state.get("graph_data", {})
+        data_id = graph_data.get("data_id")
+        
+        if not data_id:
+            error_msg = "ID dos dados do gráfico não encontrado"
+            logging.error(f"[GRAPH_GENERATION] {error_msg}")
+            state.update({
+                "graph_error": error_msg,
+                "graph_generated": False
+            })
+            return state
+        
+        # Recupera DataFrame dos dados
+        obj_manager = get_object_manager()
+        df = obj_manager.get_object(data_id)
+        
+        if df is None or df.empty:
+            error_msg = "Dados do gráfico não encontrados ou vazios"
+            logging.error(f"[GRAPH_GENERATION] {error_msg}")
+            state.update({
+                "graph_error": error_msg,
+                "graph_generated": False
+            })
+            return state
+        
+        # Gera título do gráfico baseado na pergunta do usuário
+        user_query = state.get("user_input", "")
+        title = f"Visualização: {user_query[:50]}..." if len(user_query) > 50 else f"Visualização: {user_query}"
+        
+        # Gera o gráfico
+        graph_image = await generate_graph(df, graph_type, title, user_query)
+        
+        if graph_image is None:
+            error_msg = f"Falha ao gerar gráfico do tipo {graph_type}"
+            logging.error(f"[GRAPH_GENERATION] {error_msg}")
+            state.update({
+                "graph_error": error_msg,
+                "graph_generated": False
+            })
+            return state
+        
+        # Armazena imagem do gráfico no ObjectManager
+        graph_image_id = obj_manager.store_object(graph_image, "graph_image")
+        
+        # Atualiza estado
+        state.update({
+            "graph_image_id": graph_image_id,
+            "graph_generated": True,
+            "graph_error": None
+        })
+        
+        logging.info(f"[GRAPH_GENERATION] Gráfico gerado com sucesso: {graph_type}")
+        
+    except Exception as e:
+        error_msg = f"Erro na geração de gráfico: {e}"
+        logging.error(f"[GRAPH_GENERATION] {error_msg}")
+        state.update({
+            "graph_error": error_msg,
+            "graph_generated": False
+        })
+    
+    return state
+
+async def generate_graph(df: pd.DataFrame, graph_type: str, title: str = None, user_query: str = None) -> Optional[Image.Image]:
+    """
+    Gera um gráfico com base no DataFrame e tipo especificado
+    
+    Args:
+        df: DataFrame com os dados
+        graph_type: Tipo de gráfico a ser gerado
+        title: Título do gráfico
+        user_query: Pergunta original do usuário
+        
+    Returns:
+        Imagem PIL do gráfico ou None se falhar
+    """
+    logging.info(f"[GRAPH_GENERATION] Gerando gráfico tipo {graph_type}. DataFrame: {len(df)} linhas")
+    
+    if df.empty:
+        logging.warning("[GRAPH_GENERATION] DataFrame vazio")
+        return None
+    
+    try:
+        # Preparar dados usando lógica UNIFICADA
+        prepared_df = prepare_data_for_graph_unified(df, graph_type, user_query)
+        if prepared_df.empty:
+            logging.warning("[GRAPH_GENERATION] DataFrame preparado está vazio")
+            return None
+        
+        # Configurações gerais
+        plt.style.use('default')
+        colors = plt.cm.tab10.colors
+        
+        # Gerar gráfico baseado no tipo
+        if graph_type == 'line_simple':
+            return await generate_line_simple(prepared_df, title, colors)
+        elif graph_type == 'multiline':
+            return await generate_multiline(prepared_df, title, colors)
+        elif graph_type == 'area':
+            return await generate_area(prepared_df, title, colors)
+        elif graph_type == 'bar_vertical':
+            return await generate_bar_vertical(prepared_df, title, colors)
+        elif graph_type == 'bar_horizontal':
+            return await generate_bar_horizontal(prepared_df, title, colors)
+        elif graph_type == 'bar_grouped':
+            return await generate_bar_grouped(prepared_df, title, colors)
+        elif graph_type == 'bar_stacked':
+            return await generate_bar_stacked(prepared_df, title, colors)
+        elif graph_type == 'pie':
+            return await generate_pie(prepared_df, title, colors)
+        elif graph_type == 'donut':
+            return await generate_donut(prepared_df, title, colors)
+        elif graph_type == 'pie_multiple':
+            return await generate_pie_multiple(prepared_df, title, colors)
+        else:
+            logging.warning(f"[GRAPH_GENERATION] Tipo '{graph_type}' não reconhecido, usando bar_vertical")
+            return await generate_bar_vertical(prepared_df, title, colors)
+            
+    except Exception as e:
+        logging.error(f"[GRAPH_GENERATION] Erro ao gerar gráfico: {e}")
+        return None
+
+def analyze_dataframe_structure(df: pd.DataFrame) -> Dict[str, Any]:
+    """
+    Analisa a estrutura do DataFrame e retorna informações detalhadas
+
+    Args:
+        df: DataFrame a ser analisado
+
+    Returns:
+        Dicionário com informações sobre tipos de colunas e estrutura
+    """
+    if df.empty:
+        return {
+            'numeric_cols': [],
+            'date_cols': [],
+            'categorical_cols': [],
+            'total_cols': 0,
+            'has_multiple_numerics': False,
+            'has_multiple_categoricals': False,
+            'is_suitable_for_grouping': False
+        }
+
+    # Analisar tipos de colunas de forma mais robusta
+    numeric_cols = []
+    date_cols = []
+    categorical_cols = []
+
+    for col in df.columns:
+        col_data = df[col]
+
+        # Verificar se é numérico (incluindo strings que representam números)
+        if pd.api.types.is_numeric_dtype(col_data):
+            numeric_cols.append(col)
+        elif col_data.dtype == 'object':
+            # Tentar converter para numérico
+            try:
+                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:
+                    # Verificar se é data
+                    if any(date_indicator in col.lower() for date_indicator in ['data', 'date', 'time', 'dia', 'mes', 'ano']):
+                        try:
+                            pd.to_datetime(col_data.head(3), errors='raise')
+                            date_cols.append(col)
+                        except:
+                            categorical_cols.append(col)
+                    else:
+                        categorical_cols.append(col)
+            except:
+                categorical_cols.append(col)
+        elif pd.api.types.is_datetime64_any_dtype(col_data):
+            date_cols.append(col)
+        else:
+            categorical_cols.append(col)
+
+    return {
+        'numeric_cols': numeric_cols,
+        'date_cols': date_cols,
+        'categorical_cols': categorical_cols,
+        'total_cols': len(df.columns),
+        'has_multiple_numerics': len(numeric_cols) >= 2,
+        'has_multiple_categoricals': len(categorical_cols) >= 2,
+        'is_suitable_for_grouping': len(categorical_cols) >= 2 or (len(categorical_cols) >= 1 and len(numeric_cols) >= 2)
+    }
+
+def prepare_data_for_graph_unified(df: pd.DataFrame, graph_type: str, user_query: str = None) -> pd.DataFrame:
+    """
+    FUNÇÃO UNIFICADA para preparação de dados - substitui lógica duplicada
+
+    Args:
+        df: DataFrame original
+        graph_type: Tipo de gráfico
+        user_query: Pergunta do usuário
+
+    Returns:
+        DataFrame preparado com colunas adequadas para o tipo de gráfico
+    """
+    logging.info(f"[GRAPH_GENERATION] 🔧 Preparação UNIFICADA para {graph_type}")
+
+    if df.empty:
+        logging.warning("[GRAPH_GENERATION] DataFrame vazio")
+        return df
+
+    # Fazer cópia para não modificar original
+    prepared_df = df.copy()
+
+    # Analisar estrutura do DataFrame
+    structure = analyze_dataframe_structure(prepared_df)
+    numeric_cols = structure['numeric_cols']
+    date_cols = structure['date_cols']
+    categorical_cols = structure['categorical_cols']
+
+    logging.info(f"[GRAPH_GENERATION] 📊 Estrutura: {len(numeric_cols)} numéricas, {len(date_cols)} datas, {len(categorical_cols)} categóricas")
+
+    # Preparação específica por tipo de gráfico
+    if graph_type in ['line_simple', 'area']:
+        return _prepare_for_temporal_graphs(prepared_df, date_cols, numeric_cols, categorical_cols)
+
+    elif graph_type in ['bar_vertical', 'bar_horizontal']:
+        return _prepare_for_simple_bar_graphs(prepared_df, categorical_cols, numeric_cols, graph_type)
+
+    elif graph_type in ['bar_grouped', 'bar_stacked']:
+        return _prepare_for_grouped_graphs(prepared_df, structure, graph_type)
+
+    elif graph_type in ['pie', 'donut', 'pie_multiple']:
+        return _prepare_for_pie_graphs(prepared_df, categorical_cols, numeric_cols, graph_type)
+
+    elif graph_type == 'multiline':
+        return _prepare_for_multiline_graphs(prepared_df, structure)
+
+    else:
+        logging.warning(f"[GRAPH_GENERATION] Tipo {graph_type} não reconhecido, usando preparação básica")
+        return _prepare_basic_fallback(prepared_df, categorical_cols, numeric_cols)
+
+def _prepare_for_temporal_graphs(df: pd.DataFrame, date_cols: list, numeric_cols: list, categorical_cols: list) -> pd.DataFrame:
+    """Prepara dados para gráficos temporais (linha, área)"""
+    if date_cols and numeric_cols:
+        # Usar primeira coluna de data e primeira numérica
+        x_col, y_col = date_cols[0], numeric_cols[0]
+        result_df = df[[x_col, y_col]].sort_values(by=x_col)
+        logging.info(f"[GRAPH_GENERATION] 📅 Temporal: {x_col} (data) + {y_col} (numérica)")
+        return result_df
+    elif categorical_cols and numeric_cols:
+        # Usar primeira categórica e primeira numérica
+        x_col, y_col = categorical_cols[0], numeric_cols[0]
+        result_df = df[[x_col, y_col]].sort_values(by=y_col)
+        logging.info(f"[GRAPH_GENERATION] 📊 Categórico: {x_col} + {y_col}")
+        return result_df
+    else:
+        logging.warning("[GRAPH_GENERATION] Dados insuficientes para gráfico temporal")
+        return df
+
+def _prepare_for_simple_bar_graphs(df: pd.DataFrame, categorical_cols: list, numeric_cols: list, graph_type: str) -> pd.DataFrame:
+    """Prepara dados para gráficos de barras simples"""
+    if categorical_cols and numeric_cols:
+        x_col, y_col = categorical_cols[0], numeric_cols[0]
+        result_df = df[[x_col, y_col]].sort_values(by=y_col, ascending=False)
+
+        # Limitar categorias para barras verticais
+        if graph_type == 'bar_vertical' and len(result_df) > 15:
+            result_df = result_df.head(15)
+            logging.info(f"[GRAPH_GENERATION] 📊 Limitado a 15 categorias para {graph_type}")
+
+        logging.info(f"[GRAPH_GENERATION] 📊 Barras simples: {x_col} + {y_col}")
+        return result_df
+    else:
+        logging.warning("[GRAPH_GENERATION] Dados insuficientes para gráfico de barras")
+        return df
+
+def _prepare_for_grouped_graphs(df: pd.DataFrame, structure: dict, graph_type: str) -> pd.DataFrame:
+    """
+    FUNÇÃO CRÍTICA: Prepara dados para gráficos agrupados com lógica inteligente
+    """
+    numeric_cols = structure['numeric_cols']
+    categorical_cols = structure['categorical_cols']
+    has_multiple_numerics = structure['has_multiple_numerics']
+    has_multiple_categoricals = structure['has_multiple_categoricals']
+
+    logging.info(f"[GRAPH_GENERATION] 🎯 Preparando agrupado: {len(numeric_cols)} num, {len(categorical_cols)} cat")
+
+    if has_multiple_numerics:
+        # CENÁRIO 1: Múltiplas numéricas - usar primeira categórica + todas numéricas
+        cols_to_keep = [categorical_cols[0]] + numeric_cols
+        result_df = df[cols_to_keep]
+        logging.info(f"[GRAPH_GENERATION] ✅ Múltiplas numéricas: {cols_to_keep}")
+        return result_df
+
+    elif len(numeric_cols) == 1 and has_multiple_categoricals:
+        # CENÁRIO 2: 1 numérica + múltiplas categóricas - AGRUPAMENTO POR COR
+        # Usar TODAS as categóricas + a numérica
+        cols_to_keep = categorical_cols + numeric_cols
+        result_df = df[cols_to_keep]
+        logging.info(f"[GRAPH_GENERATION] ✅ Agrupamento por cor: {cols_to_keep}")
+        return result_df
+
+    elif len(numeric_cols) == 1 and len(categorical_cols) == 1:
+        # CENÁRIO 3: 1 numérica + 1 categórica - gráfico simples
+        cols_to_keep = categorical_cols + numeric_cols
+        result_df = df[cols_to_keep]
+        logging.info(f"[GRAPH_GENERATION] ⚠️ Dados simples para agrupado: {cols_to_keep}")
+        return result_df
+
+    else:
+        # CENÁRIO 4: Dados inadequados
+        logging.warning("[GRAPH_GENERATION] ❌ Dados inadequados para gráfico agrupado")
+        return df
+
+def _prepare_for_pie_graphs(df: pd.DataFrame, categorical_cols: list, numeric_cols: list, graph_type: str) -> pd.DataFrame:
+    """Prepara dados para gráficos de pizza"""
+    if categorical_cols and numeric_cols:
+        cat_col, val_col = categorical_cols[0], numeric_cols[0]
+
+        if graph_type == 'pie_multiple' and len(categorical_cols) >= 2:
+            # Para pizzas múltiplas, manter 2 categóricas + 1 numérica
+            result_df = df[[categorical_cols[0], categorical_cols[1], val_col]]
+            logging.info(f"[GRAPH_GENERATION] 🥧 Pizzas múltiplas: {result_df.columns.tolist()}")
+        else:
+            # Agrupar e somar valores para pizza simples/donut
+            result_df = df.groupby(cat_col)[val_col].sum().reset_index()
+            result_df = result_df.sort_values(by=val_col, ascending=False)
+
+            # Limitar a 10 categorias
+            if len(result_df) > 10:
+                top_9 = result_df.head(9)
+                others_sum = result_df.iloc[9:][val_col].sum()
+                if others_sum > 0:
+                    others_row = pd.DataFrame({cat_col: ['Outros'], val_col: [others_sum]})
+                    result_df = pd.concat([top_9, others_row], ignore_index=True)
+                else:
+                    result_df = top_9
+
+            logging.info(f"[GRAPH_GENERATION] 🥧 Pizza: {cat_col} + {val_col} ({len(result_df)} categorias)")
+
+        return result_df
+    else:
+        logging.warning("[GRAPH_GENERATION] Dados insuficientes para gráfico de pizza")
+        return df
+
+def _prepare_for_multiline_graphs(df: pd.DataFrame, structure: dict) -> pd.DataFrame:
+    """Prepara dados para gráficos de múltiplas linhas"""
+    date_cols = structure['date_cols']
+    numeric_cols = structure['numeric_cols']
+    categorical_cols = structure['categorical_cols']
+
+    if date_cols and len(numeric_cols) >= 2:
+        # Data + múltiplas numéricas
+        cols_to_keep = [date_cols[0]] + numeric_cols
+        result_df = df[cols_to_keep].sort_values(by=date_cols[0])
+        logging.info(f"[GRAPH_GENERATION] 📈 Multilinhas temporais: {cols_to_keep}")
+        return result_df
+    elif categorical_cols and len(numeric_cols) >= 2:
+        # Categórica + múltiplas numéricas
+        cols_to_keep = [categorical_cols[0]] + numeric_cols
+        result_df = df[cols_to_keep]
+        logging.info(f"[GRAPH_GENERATION] 📈 Multilinhas categóricas: {cols_to_keep}")
+        return result_df
+    else:
+        logging.warning("[GRAPH_GENERATION] Dados insuficientes para multilinhas")
+        return df
+
+def _prepare_basic_fallback(df: pd.DataFrame, categorical_cols: list, numeric_cols: list) -> pd.DataFrame:
+    """Preparação básica de fallback"""
+    if categorical_cols and numeric_cols:
+        result_df = df[[categorical_cols[0], numeric_cols[0]]]
+        logging.info(f"[GRAPH_GENERATION] 🔄 Fallback básico: {result_df.columns.tolist()}")
+        return result_df
+    else:
+        logging.warning("[GRAPH_GENERATION] Dados inadequados para qualquer gráfico")
+        return df
+
+def save_plot_to_image() -> Image.Image:
+    """
+    Salva o plot atual do matplotlib como imagem PIL
+
+    Returns:
+        Imagem PIL
+    """
+    buf = io.BytesIO()
+    plt.savefig(buf, format='png', dpi=100, bbox_inches='tight', facecolor='white')
+    buf.seek(0)
+    img = Image.open(buf)
+    plt.close()  # Importante: fechar o plot para liberar memória
+    return img
+
+# ==================== FUNÇÕES DE GERAÇÃO ESPECÍFICAS ====================
+
+async def generate_line_simple(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera gráfico de linha simples"""
+    if len(df.columns) < 2:
+        return None
+
+    x_col, y_col = df.columns[0], df.columns[1]
+    is_date = pd.api.types.is_datetime64_any_dtype(df[x_col])
+
+    plt.figure(figsize=(12, 6))
+
+    if is_date:
+        plt.plot(df[x_col], df[y_col], marker='o', linewidth=2, color=colors[0])
+        plt.gcf().autofmt_xdate()
+        plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y'))
+    else:
+        plt.plot(range(len(df)), df[y_col], marker='o', linewidth=2, color=colors[0])
+        plt.xticks(range(len(df)), df[x_col], rotation=45, ha='right')
+
+    plt.xlabel(x_col)
+    plt.ylabel(y_col)
+    plt.title(title or f"{y_col} por {x_col}")
+    plt.grid(True, linestyle='--', alpha=0.7)
+    plt.tight_layout()
+
+    return save_plot_to_image()
+
+async def generate_multiline(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera gráfico de múltiplas linhas"""
+    if len(df.columns) < 2:
+        return None
+
+    x_col = df.columns[0]
+    y_cols = [col for col in df.columns[1:] if pd.api.types.is_numeric_dtype(df[col])]
+
+    if not y_cols:
+        return await generate_line_simple(df, title, colors)
+
+    is_date = pd.api.types.is_datetime64_any_dtype(df[x_col])
+
+    plt.figure(figsize=(12, 6))
+
+    for i, y_col in enumerate(y_cols):
+        if is_date:
+            plt.plot(df[x_col], df[y_col], marker='o', linewidth=2,
+                    label=y_col, color=colors[i % len(colors)])
+        else:
+            plt.plot(range(len(df)), df[y_col], marker='o', linewidth=2,
+                    label=y_col, color=colors[i % len(colors)])
+
+    if is_date:
+        plt.gcf().autofmt_xdate()
+        plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y'))
+    else:
+        plt.xticks(range(len(df)), df[x_col], rotation=45, ha='right')
+
+    plt.xlabel(x_col)
+    plt.ylabel("Valores")
+    plt.title(title or f"Comparação por {x_col}")
+    plt.legend(title="Séries", loc='best')
+    plt.grid(True, linestyle='--', alpha=0.7)
+    plt.tight_layout()
+
+    return save_plot_to_image()
+
+async def generate_area(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera gráfico de área"""
+    if len(df.columns) < 2:
+        return None
+
+    x_col, y_col = df.columns[0], df.columns[1]
+    is_date = pd.api.types.is_datetime64_any_dtype(df[x_col])
+
+    plt.figure(figsize=(12, 6))
+
+    if is_date:
+        plt.fill_between(df[x_col], df[y_col], alpha=0.5, color=colors[0])
+        plt.plot(df[x_col], df[y_col], color=colors[0], linewidth=2)
+        plt.gcf().autofmt_xdate()
+        plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%d/%m/%Y'))
+    else:
+        plt.fill_between(range(len(df)), df[y_col], alpha=0.5, color=colors[0])
+        plt.plot(range(len(df)), df[y_col], color=colors[0], linewidth=2)
+        plt.xticks(range(len(df)), df[x_col], rotation=45, ha='right')
+
+    plt.xlabel(x_col)
+    plt.ylabel(y_col)
+    plt.title(title or f"{y_col} por {x_col}")
+    plt.grid(True, linestyle='--', alpha=0.7)
+    plt.tight_layout()
+
+    return save_plot_to_image()
+
+async def generate_bar_vertical(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera gráfico de barras verticais"""
+    if len(df.columns) < 2:
+        return None
+
+    x_col, y_col = df.columns[0], df.columns[1]
+
+    # Preparar dados numéricos - converter strings com vírgula para float
+    df_plot = df.copy()
+    try:
+        if df_plot[y_col].dtype == 'object':
+            # Converte strings para números, tratando vírgulas como separador decimal
+            df_plot[y_col] = pd.to_numeric(df_plot[y_col].astype(str).str.replace(',', '.'), errors='coerce')
+
+        # Remove linhas com valores não numéricos
+        df_plot = df_plot.dropna(subset=[y_col])
+
+        if df_plot.empty:
+            logging.error(f"[GRAPH_GENERATION] Nenhum valor numérico válido encontrado na coluna {y_col}")
+            return None
+
+    except Exception as e:
+        logging.error(f"[GRAPH_GENERATION] Erro ao converter dados para numérico: {e}")
+        return None
+
+    plt.figure(figsize=(12, 8))
+    bars = plt.bar(range(len(df_plot)), df_plot[y_col], color=colors[0])
+
+    # Adicionar valores nas barras
+    try:
+        max_value = df_plot[y_col].max()
+        for i, bar in enumerate(bars):
+            height = bar.get_height()
+            if isinstance(height, (int, float)) and not pd.isna(height):
+                plt.text(bar.get_x() + bar.get_width()/2., height + 0.02 * max_value,
+                        f'{height:,.0f}', ha='center', fontsize=9)
+    except Exception as e:
+        logging.warning(f"[GRAPH_GENERATION] Erro ao adicionar valores nas barras: {e}")
+
+    plt.xlabel(x_col)
+    plt.ylabel(y_col)
+    plt.title(title or f"{y_col} por {x_col}")
+    plt.xticks(range(len(df_plot)), df_plot[x_col], rotation=45, ha='right')
+    plt.grid(True, linestyle='--', alpha=0.7, axis='y')
+    plt.tight_layout()
+
+    return save_plot_to_image()
+
+async def generate_bar_horizontal(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera gráfico de barras horizontais"""
+    if len(df.columns) < 2:
+        return None
+
+    x_col, y_col = df.columns[0], df.columns[1]
+
+    # Preparar dados numéricos - converter strings com vírgula para float
+    df_plot = df.copy()
+    try:
+        if df_plot[y_col].dtype == 'object':
+            # Converte strings para números, tratando vírgulas como separador decimal
+            df_plot[y_col] = pd.to_numeric(df_plot[y_col].astype(str).str.replace(',', '.'), errors='coerce')
+
+        # Remove linhas com valores não numéricos
+        df_plot = df_plot.dropna(subset=[y_col])
+
+        if df_plot.empty:
+            logging.error(f"[GRAPH_GENERATION] Nenhum valor numérico válido encontrado na coluna {y_col}")
+            return None
+
+    except Exception as e:
+        logging.error(f"[GRAPH_GENERATION] Erro ao converter dados para numérico: {e}")
+        return None
+
+    plt.figure(figsize=(12, max(6, len(df_plot) * 0.4)))
+    bars = plt.barh(range(len(df_plot)), df_plot[y_col], color=colors[0])
+
+    # Adicionar valores nas barras
+    try:
+        max_value = df_plot[y_col].max()
+        for i, bar in enumerate(bars):
+            width = bar.get_width()
+            if isinstance(width, (int, float)) and not pd.isna(width):
+                plt.text(width + 0.02 * max_value, bar.get_y() + bar.get_height()/2.,
+                        f'{width:,.0f}', va='center', fontsize=9)
+    except Exception as e:
+        logging.warning(f"[GRAPH_GENERATION] Erro ao adicionar valores nas barras: {e}")
+
+    plt.xlabel(y_col)
+    plt.ylabel(x_col)
+    plt.title(title or f"{y_col} por {x_col}")
+    plt.yticks(range(len(df_plot)), df_plot[x_col])
+    plt.grid(True, linestyle='--', alpha=0.7, axis='x')
+    plt.tight_layout()
+
+    return save_plot_to_image()
+
+async def generate_bar_grouped(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """
+    FUNÇÃO REFATORADA: Gera gráfico de barras agrupadas com fallbacks inteligentes
+    """
+    logging.info(f"[GRAPH_GENERATION] 🎯 Gerando barras agrupadas REFATORADO. Colunas: {df.columns.tolist()}")
+
+    if len(df.columns) < 2:
+        logging.warning("[GRAPH_GENERATION] ❌ Dados insuficientes para gráfico agrupado")
+        return None
+
+    # Analisar estrutura dos dados
+    structure = analyze_dataframe_structure(df)
+    numeric_cols = structure['numeric_cols']
+    categorical_cols = structure['categorical_cols']
+
+    logging.info(f"[GRAPH_GENERATION] 📊 Estrutura: {len(numeric_cols)} numéricas, {len(categorical_cols)} categóricas")
+
+    if not numeric_cols:
+        logging.warning("[GRAPH_GENERATION] ❌ Nenhuma coluna numérica encontrada")
+        return await generate_bar_vertical(df, title, colors)
+
+    # DECISÃO INTELIGENTE baseada na estrutura dos dados
+    if len(numeric_cols) >= 2:
+        # CENÁRIO 1: Múltiplas numéricas - gráfico agrupado tradicional
+        return await _generate_multi_numeric_grouped(df, title, colors, categorical_cols[0], numeric_cols)
+
+    elif len(numeric_cols) == 1 and len(categorical_cols) >= 2:
+        # CENÁRIO 2: 1 numérica + múltiplas categóricas - agrupamento por cor
+        return await _generate_color_grouped_bars(df, title, colors, categorical_cols, numeric_cols[0])
+
+    elif len(numeric_cols) == 1 and len(categorical_cols) == 1:
+        # CENÁRIO 3: Dados simples - fallback inteligente para barras verticais
+        logging.info("[GRAPH_GENERATION] ⚠️ Dados simples, usando barras verticais")
+        return await generate_bar_vertical(df, title, colors)
+
+    else:
+        # CENÁRIO 4: Estrutura inadequada
+        logging.warning("[GRAPH_GENERATION] ❌ Estrutura de dados inadequada para agrupamento")
+        return await generate_bar_vertical(df, title, colors)
+
+async def _generate_multi_numeric_grouped(df: pd.DataFrame, title: str, colors, x_col: str, y_cols: list) -> Optional[Image.Image]:
+    """
+    Gera gráfico agrupado com múltiplas colunas numéricas (cenário tradicional)
+    """
+    logging.info(f"[GRAPH_GENERATION] 📊 Múltiplas numéricas: {x_col} + {y_cols}")
+
+    # Converter colunas numéricas se necessário
+    for col in y_cols:
+        if df[col].dtype == 'object':
+            df[col] = pd.to_numeric(df[col].astype(str).str.replace(',', '.'), errors='coerce')
+
+    # Remover linhas com valores NaN
+    df_clean = df.dropna(subset=y_cols)
+
+    if df_clean.empty:
+        logging.error("[GRAPH_GENERATION] ❌ Todos os valores são NaN após conversão")
+        return None
+
+    # Verificar diferença de escala entre colunas
+    col_ranges = {col: df_clean[col].max() - df_clean[col].min() for col in y_cols}
+    max_range = max(col_ranges.values())
+    min_range = min(col_ranges.values())
+
+    if max_range > 0 and min_range > 0 and (max_range / min_range) > 100:
+        # Escalas muito diferentes - usar eixos duplos
+        logging.info("[GRAPH_GENERATION] 📊 Escalas diferentes, usando eixos duplos")
+        return await _generate_dual_axis_chart(df_clean, title, colors, x_col, y_cols[0], y_cols[1])
+
+    # Gráfico agrupado normal
+    x_pos = np.arange(len(df_clean))
+    width = 0.8 / len(y_cols)
+
+    fig, ax = plt.subplots(figsize=(14, 8))
+
+    for i, col in enumerate(y_cols):
+        offset = width * i - width * (len(y_cols) - 1) / 2
+        bars = ax.bar(x_pos + offset, df_clean[col], width, label=col,
+                     color=colors[i % len(colors)], alpha=0.8)
+
+        # Adicionar valores nas barras
+        for bar in bars:
+            height = bar.get_height()
+            if height > 0:
+                ax.text(bar.get_x() + bar.get_width()/2., height + height * 0.02,
+                       f'{height:.0f}', ha='center', fontsize=8)
+
+    ax.set_xlabel(x_col)
+    ax.set_ylabel('Valores')
+    ax.set_title(title or f"Comparação de {', '.join(y_cols)} por {x_col}")
+    ax.set_xticks(x_pos)
+    ax.set_xticklabels(df_clean[x_col], rotation=45, ha='right')
+    ax.legend()
+    ax.grid(True, linestyle='--', alpha=0.7, axis='y')
+    plt.tight_layout()
+
+    logging.info(f"[GRAPH_GENERATION] ✅ Gráfico agrupado tradicional criado: {len(y_cols)} métricas")
+    return save_plot_to_image()
+
+async def _generate_color_grouped_bars(df: pd.DataFrame, title: str, colors, categorical_cols: list, y_col: str) -> Optional[Image.Image]:
+    """
+    Gera gráfico agrupado por cor usando múltiplas categóricas (CENÁRIO CRÍTICO)
+    """
+    x_col = categorical_cols[0]
+    group_col = categorical_cols[1] if len(categorical_cols) > 1 else None
+
+    logging.info(f"[GRAPH_GENERATION] 🎨 Agrupamento por cor: {x_col} (X) + {y_col} (Y) + {group_col} (cor)")
+
+    if not group_col:
+        logging.warning("[GRAPH_GENERATION] ⚠️ Sem coluna para agrupamento, usando gráfico simples")
+        return await generate_bar_vertical(df[[x_col, y_col]], title, colors)
+
+    # Converter coluna numérica se necessário
+    if df[y_col].dtype == 'object':
+        df[y_col] = pd.to_numeric(df[y_col].astype(str).str.replace(',', '.'), errors='coerce')
+
+    # Remover linhas com valores NaN
+    df_clean = df.dropna(subset=[y_col])
+
+    if df_clean.empty:
+        logging.error("[GRAPH_GENERATION] ❌ Todos os valores são NaN após conversão")
+        return None
+
+    # Obter categorias únicas
+    unique_groups = df_clean[group_col].unique()
+    unique_x = df_clean[x_col].unique()
+
+    logging.info(f"[GRAPH_GENERATION] 🎯 Grupos: {unique_groups} | X: {len(unique_x)} categorias")
+
+    # Configurar gráfico
+    x_pos = np.arange(len(unique_x))
+    width = 0.8 / len(unique_groups)
+
+    fig, ax = plt.subplots(figsize=(14, 8))
+
+    # Criar barras para cada grupo
+    for i, group in enumerate(unique_groups):
+        group_data = df_clean[df_clean[group_col] == group]
+
+        # Criar array de valores para cada posição X
+        values = []
+        for x_val in unique_x:
+            matching_rows = group_data[group_data[x_col] == x_val]
+            if not matching_rows.empty:
+                values.append(matching_rows[y_col].iloc[0])
+            else:
+                values.append(0)
+
+        # Calcular posição das barras
+        offset = width * i - width * (len(unique_groups) - 1) / 2
+        bars = ax.bar(x_pos + offset, values, width, label=f"{group_col}: {group}",
+                     color=colors[i % len(colors)], alpha=0.8)
+
+        # Adicionar valores nas barras
+        for bar, value in zip(bars, values):
+            if value > 0:
+                ax.text(bar.get_x() + bar.get_width()/2., value + value * 0.02,
+                       f'{value:.0f}', ha='center', fontsize=8)
+
+    # Configurações do gráfico
+    ax.set_xlabel(x_col)
+    ax.set_ylabel(y_col)
+    ax.set_title(title or f"{y_col} por {x_col} (agrupado por {group_col})")
+    ax.set_xticks(x_pos)
+    ax.set_xticklabels(unique_x, rotation=45, ha='right')
+    ax.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+    ax.grid(True, linestyle='--', alpha=0.7, axis='y')
+    plt.tight_layout()
+
+    logging.info(f"[GRAPH_GENERATION] ✅ Gráfico agrupado por cor criado: {len(unique_groups)} grupos")
+    return save_plot_to_image()
+
+async def _generate_dual_axis_chart(df: pd.DataFrame, title: str, colors, x_col: str, y1_col: str, y2_col: str) -> Optional[Image.Image]:
+    """
+    Gera gráfico com eixos duplos para métricas com escalas diferentes
+    """
+    logging.info(f"[GRAPH_GENERATION] 📊 Eixos duplos: {y1_col} (esq) + {y2_col} (dir)")
+
+    fig, ax1 = plt.subplots(figsize=(14, 8))
+
+    # Primeiro eixo Y (esquerda)
+    x_pos = np.arange(len(df))
+    width = 0.35
+
+    bars1 = ax1.bar(x_pos - width/2, df[y1_col], width, label=y1_col,
+                    color=colors[0], alpha=0.8)
+    ax1.set_xlabel(x_col)
+    ax1.set_ylabel(y1_col, color=colors[0])
+    ax1.tick_params(axis='y', labelcolor=colors[0])
+
+    # Segundo eixo Y (direita)
+    ax2 = ax1.twinx()
+    bars2 = ax2.bar(x_pos + width/2, df[y2_col], width, label=y2_col,
+                    color=colors[1], alpha=0.8)
+    ax2.set_ylabel(y2_col, color=colors[1])
+    ax2.tick_params(axis='y', labelcolor=colors[1])
+
+    # Configurações comuns
+    ax1.set_xticks(x_pos)
+    ax1.set_xticklabels(df[x_col], rotation=45, ha='right')
+    ax1.grid(True, linestyle='--', alpha=0.7, axis='y')
+
+    # Adicionar valores nas barras
+    for bar in bars1:
+        height = bar.get_height()
+        if height > 0:
+            ax1.text(bar.get_x() + bar.get_width()/2., height + height * 0.02,
+                    f'{height:.0f}', ha='center', fontsize=8)
+
+    for bar in bars2:
+        height = bar.get_height()
+        if height > 0:
+            ax2.text(bar.get_x() + bar.get_width()/2., height + height * 0.02,
+                    f'{height:.0f}', ha='center', fontsize=8)
+
+    plt.title(title or f"{y1_col} e {y2_col} por {x_col}")
+    plt.tight_layout()
+
+    logging.info(f"[GRAPH_GENERATION] ✅ Gráfico com eixos duplos criado: {y1_col} + {y2_col}")
+    return save_plot_to_image()
+
+# Função removida - substituída pela nova lógica unificada
+
+# Função removida - substituída pela nova lógica unificada em _generate_color_grouped_bars()
+
+async def generate_bar_stacked(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera gráfico de barras empilhadas"""
+    if len(df.columns) < 3:
+        return await generate_bar_vertical(df, title, colors)
+
+    x_col = df.columns[0]
+    y_cols = [col for col in df.columns[1:] if pd.api.types.is_numeric_dtype(df[col])]
+
+    if not y_cols:
+        return await generate_bar_vertical(df, title, colors)
+
+    fig, ax = plt.subplots(figsize=(12, 8))
+    bottom = np.zeros(len(df))
+
+    for i, col in enumerate(y_cols):
+        bars = ax.bar(range(len(df)), df[col], bottom=bottom, label=col, color=colors[i % len(colors)])
+
+        # Adicionar valores nas barras
+        for j, bar in enumerate(bars):
+            height = bar.get_height()
+            if isinstance(height, (int, float)) and height > 0:
+                ax.text(bar.get_x() + bar.get_width()/2., bottom[j] + height/2,
+                        f'{height:.2f}', ha='center', va='center', fontsize=8, color='white')
+
+        bottom += df[col].fillna(0)
+
+    ax.set_xlabel(x_col)
+    ax.set_ylabel('Valores')
+    ax.set_title(title or f"Distribuição por {x_col}")
+    ax.set_xticks(range(len(df)))
+    ax.set_xticklabels(df[x_col], rotation=45, ha='right')
+    ax.legend()
+    plt.tight_layout()
+
+    return save_plot_to_image()
+
+async def generate_pie(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera gráfico de pizza"""
+    if len(df.columns) < 2:
+        return None
+
+    label_col, value_col = df.columns[0], df.columns[1]
+
+    # Preparar dados numéricos - converter strings com vírgula para float
+    df_plot = df.copy()
+    try:
+        if df_plot[value_col].dtype == 'object':
+            # Converte strings para números, tratando vírgulas como separador decimal
+            df_plot[value_col] = pd.to_numeric(df_plot[value_col].astype(str).str.replace(',', '.'), errors='coerce')
+
+        # Remove linhas com valores não numéricos, negativos ou zero
+        df_plot = df_plot.dropna(subset=[value_col])
+        df_plot = df_plot[df_plot[value_col] > 0]
+
+        if df_plot.empty:
+            logging.error(f"[GRAPH_GENERATION] Nenhum valor numérico positivo encontrado na coluna {value_col}")
+            return await generate_bar_vertical(df, title, colors)
+
+    except Exception as e:
+        logging.error(f"[GRAPH_GENERATION] Erro ao converter dados para numérico: {e}")
+        return await generate_bar_vertical(df, title, colors)
+
+    plt.figure(figsize=(10, 10))
+
+    # Calcular percentuais para os rótulos
+    total = df_plot[value_col].sum()
+    labels = [f'{label} ({val:,.0f}, {val/total:.1%})' for label, val in zip(df_plot[label_col], df_plot[value_col])]
+
+    plt.pie(df_plot[value_col], labels=labels, autopct='%1.1f%%',
+            startangle=90, shadow=False, colors=colors[:len(df_plot)])
+
+    plt.axis('equal')
+    plt.title(title or f"Distribuição de {value_col} por {label_col}")
+    plt.tight_layout()
+
+    return save_plot_to_image()
+
+async def generate_donut(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera gráfico de donut"""
+    if len(df.columns) < 2:
+        return None
+
+    label_col, value_col = df.columns[0], df.columns[1]
+
+    # Preparar dados numéricos - converter strings com vírgula para float
+    df_plot = df.copy()
+    try:
+        if df_plot[value_col].dtype == 'object':
+            # Converte strings para números, tratando vírgulas como separador decimal
+            df_plot[value_col] = pd.to_numeric(df_plot[value_col].astype(str).str.replace(',', '.'), errors='coerce')
+
+        # Remove linhas com valores não numéricos, negativos ou zero
+        df_plot = df_plot.dropna(subset=[value_col])
+        df_plot = df_plot[df_plot[value_col] > 0]
+
+        if df_plot.empty:
+            logging.error(f"[GRAPH_GENERATION] Nenhum valor numérico positivo encontrado na coluna {value_col}")
+            return await generate_bar_vertical(df, title, colors)
+
+    except Exception as e:
+        logging.error(f"[GRAPH_GENERATION] Erro ao converter dados para numérico: {e}")
+        return await generate_bar_vertical(df, title, colors)
+
+    plt.figure(figsize=(10, 10))
+
+    # Calcular percentuais para os rótulos
+    total = df_plot[value_col].sum()
+    labels = [f'{label} ({val:,.0f}, {val/total:.1%})' for label, val in zip(df_plot[label_col], df_plot[value_col])]
+
+    # Criar gráfico de donut (pizza com círculo central)
+    plt.pie(df_plot[value_col], labels=labels, autopct='%1.1f%%',
+            startangle=90, shadow=False, colors=colors[:len(df_plot)],
+            wedgeprops=dict(width=0.5))  # Largura do anel
+
+    plt.axis('equal')
+    plt.title(title or f"Distribuição de {value_col} por {label_col}")
+    plt.tight_layout()
+
+    return save_plot_to_image()
+
+async def generate_pie_multiple(df: pd.DataFrame, title: str, colors) -> Optional[Image.Image]:
+    """Gera múltiplos gráficos de pizza"""
+    if len(df.columns) < 3:
+        return await generate_pie(df, title, colors)
+
+    cat1, cat2, val_col = df.columns[0], df.columns[1], df.columns[2]
+
+    # Verificar se o valor é numérico
+    if not pd.api.types.is_numeric_dtype(df[val_col]):
+        return await generate_bar_grouped(df, title, colors)
+
+    # Agrupar dados
+    grouped = df.groupby([cat1, cat2])[val_col].sum().unstack().fillna(0)
+
+    # Determinar layout da grade
+    n_groups = len(grouped)
+    if n_groups == 0:
+        return None
+
+    cols = min(3, n_groups)  # Máximo 3 colunas
+    rows = (n_groups + cols - 1) // cols  # Arredondar para cima
+
+    # Criar subplots
+    fig, axes = plt.subplots(rows, cols, figsize=(15, 5 * rows))
+    if rows == 1 and cols == 1:
+        axes = np.array([axes])  # Garantir que axes seja um array
+    axes = axes.flatten()
+
+    # Plotar cada pizza
+    for i, (group_name, group_data) in enumerate(grouped.iterrows()):
+        if i < len(axes):
+            # Remover valores zero
+            data = group_data[group_data > 0]
+
+            if not data.empty:
+                # Calcular percentuais
+                total = data.sum()
+
+                # Criar rótulos com valores e percentuais
+                labels = [f'{idx} ({val:.2f}, {val/total:.1%})' for idx, val in data.items()]
+
+                # Plotar pizza
+                axes[i].pie(data, labels=labels, autopct='%1.1f%%',
+                           startangle=90, colors=colors[:len(data)])
+                axes[i].set_title(f"{group_name}")
+                axes[i].axis('equal')
+
+    # Esconder eixos não utilizados
+    for j in range(i + 1, len(axes)):
+        axes[j].axis('off')
+
+    plt.suptitle(title or f"Distribuição de {val_col} por {cat2} para cada {cat1}", fontsize=16)
+    plt.tight_layout()
+    plt.subplots_adjust(top=0.9)
+
+    return save_plot_to_image()

nodes/graph_selection_node.py

@@ -0,0 +1,147 @@
+"""
+Nó para seleção do tipo de gráfico usando LLM - REFATORADO COMPLETO
+"""
+import logging
+import re
+import pandas as pd
+from typing import Dict, Any, Optional
+
+from agents.tools import (
+    generate_graph_type_context,
+    extract_sql_query_from_response
+)
+from utils.config import OPENAI_API_KEY
+from langchain_openai import ChatOpenAI
+from utils.object_manager import get_object_manager
+
+# Mapeamento DIRETO no arquivo para evitar problemas externos
+GRAPH_TYPE_MAPPING = {
+    "1": "line_simple",
+    "2": "multiline",
+    "3": "area",
+    "4": "bar_vertical",
+    "5": "bar_horizontal",
+    "6": "bar_grouped",
+    "7": "bar_stacked",
+    "8": "pie",
+    "9": "donut",
+    "10": "pie_multiple"
+}
+
+async def graph_selection_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó REFATORADO para seleção do tipo de gráfico usando LLM
+    """
+    logging.info("[GRAPH_SELECTION_NEW] 🚀 Iniciando seleção REFATORADA")
+
+    try:
+        # 1. Verificações básicas
+        if state.get("query_type") != "sql_query_graphic":
+            logging.info("[GRAPH_SELECTION_NEW] Query não requer gráfico")
+            return state
+
+        # 2. Obter SQL query
+        sql_query = state.get("sql_query_extracted")
+        if not sql_query:
+            sql_query = extract_sql_query_from_response(state.get("response", ""))
+
+        if not sql_query:
+            logging.error("[GRAPH_SELECTION_NEW] ❌ SQL query não encontrada")
+            state.update({"graph_error": "SQL query não encontrada", "graph_generated": False})
+            return state
+
+        # 3. Obter dados
+        obj_manager = get_object_manager()
+        engine = obj_manager.get_engine(state.get("engine_id"))
+        if not engine:
+            logging.error("[GRAPH_SELECTION_NEW] ❌ Engine não encontrada")
+            state.update({"graph_error": "Engine não encontrada", "graph_generated": False})
+            return state
+
+        # 4. Executar query
+        try:
+            df_result = pd.read_sql_query(sql_query, engine)
+            if df_result.empty:
+                logging.error("[GRAPH_SELECTION_NEW] ❌ Dados vazios")
+                state.update({"graph_error": "Dados vazios", "graph_generated": False})
+                return state
+        except Exception as e:
+            logging.error(f"[GRAPH_SELECTION_NEW] ❌ Erro na query: {e}")
+            state.update({"graph_error": f"Erro na query: {e}", "graph_generated": False})
+            return state
+
+        # 5. Preparar contexto
+        user_query = state.get("user_input", "")
+        df_sample = df_result.head(3)
+        graph_context = generate_graph_type_context(user_query, sql_query, df_result.columns.tolist(), df_sample)
+
+        # 6. Chamar LLM de forma LIMPA
+        graph_type = await call_llm_for_graph_selection(graph_context, user_query)
+
+        logging.error(f"🎯 [RESULTADO_FINAL] Tipo selecionado: '{graph_type}'")
+
+        # 7. Armazenar resultado
+        graph_data_id = obj_manager.store_object(df_result, "graph_data")
+        state.update({
+            "graph_type": graph_type,
+            "graph_data": {
+                "data_id": graph_data_id,
+                "columns": df_result.columns.tolist(),
+                "rows": len(df_result),
+                "sample": df_sample.to_dict()
+            },
+            "graph_error": None
+        })
+
+        return state
+
+    except Exception as e:
+        logging.error(f"[GRAPH_SELECTION_NEW] ❌ Erro geral: {e}")
+        state.update({"graph_error": f"Erro geral: {e}", "graph_generated": False})
+        return state
+
+async def call_llm_for_graph_selection(graph_context: str, user_query: str) -> str:
+    """
+    Função NOVA e LIMPA para chamar LLM sem interferências
+    """
+    logging.error("🔥 [LLM_CALL] Iniciando chamada LIMPA da LLM")
+
+    # Verificação básica
+    if not OPENAI_API_KEY:
+        logging.error("🔥 [LLM_CALL] OpenAI não configurada")
+        return "line_simple"
+
+    try:
+        # Criar LLM com configuração limpa
+        llm = ChatOpenAI(
+            model="gpt-4o",
+            temperature=0,
+            max_tokens=5,
+            timeout=30
+        )
+
+        # Log do contexto
+        logging.error("🔥 [LLM_CALL] Contexto enviado:")
+        logging.error(f"'{graph_context}...'")
+
+        # Agora a pergunta real
+        real_response = llm.invoke(graph_context)
+        real_content = real_response.content.strip()
+
+        logging.error(f"🔥 [LLM_CALL] Resposta REAL: '{real_content}'")
+
+        # Extrair número da resposta
+        number_match = re.search(r'\b([1-9]|10)\b', real_content)
+        if number_match:
+            number = number_match.group(0)
+            graph_type = GRAPH_TYPE_MAPPING.get(number, "line_simple")
+            logging.error(f"🔥 [LLM_CALL] Número: {number} → Tipo: {graph_type}")
+            return graph_type
+        else:
+            logging.error(f"🔥 [LLM_CALL] Número não encontrado em: '{real_content}'")
+            return "line_simple"
+
+    except Exception as e:
+        logging.error(f"🔥 [LLM_CALL] ERRO: {e}")
+        return "line_simple"
+

nodes/processing_node.py

@@ -0,0 +1,230 @@
+"""
+Nó para processamento de contexto inicial usando Processing Agent
+"""
+import logging
+import pandas as pd
+from typing import Dict, Any
+
+from agents.processing_agent import ProcessingAgentManager
+from agents.tools import prepare_processing_context
+from utils.object_manager import get_object_manager
+
+
+async def process_initial_context_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para processar contexto inicial com Processing Agent (opcional)
+    
+    Args:
+        state: Estado atual do agente
+        
+    Returns:
+        Estado atualizado com contexto processado
+    """
+    # Verifica se o processing está habilitado
+    processing_enabled = state.get("processing_enabled", False)
+    logging.info(f"[PROCESSING NODE] Processing enabled: {processing_enabled}")
+
+    if not processing_enabled:
+        logging.info("[PROCESSING NODE] Processing Agent desabilitado - pulando nó")
+        return state
+
+    logging.info("[PROCESSING NODE] ===== INICIANDO NÓ DE PROCESSAMENTO =====")
+    
+    try:
+        user_input = state.get("user_input", "")
+        processing_model = state.get("processing_model", "gpt-4o-mini")
+
+        logging.info(f"[PROCESSING NODE] Entrada do usuário: {user_input[:100]}...")
+        logging.info(f"[PROCESSING NODE] Modelo selecionado: {processing_model}")
+
+        if not user_input:
+            logging.warning("[PROCESSING NODE] Entrada do usuário não disponível")
+            return state
+        
+        # Acessa diretamente o banco de dados para criar amostra
+        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")
+                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
+            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)
+
+                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)}")
+
+        except Exception as e:
+            logging.error(f"[PROCESSING NODE] Erro ao acessar banco de dados: {e}")
+            logging.error(f"[PROCESSING NODE] Detalhes do erro: {str(e)}")
+            return state
+        
+        # Recupera ou cria Processing Agent
+        processing_agent_id = state.get("processing_agent_id")
+        
+        if processing_agent_id:
+            processing_agent = obj_manager.get_processing_agent(processing_agent_id)
+            # Verifica se precisa recriar com modelo diferente
+            if processing_agent and processing_agent.model_name != processing_model:
+                logging.info(f"[PROCESSING NODE] Recriando Processing Agent com modelo {processing_model}")
+                processing_agent.recreate_llm(processing_model)
+            else:
+                logging.info(f"[PROCESSING NODE] Reutilizando Processing Agent existente com modelo {processing_agent.model_name}")
+        else:
+            # Cria novo Processing Agent
+            logging.info(f"[PROCESSING NODE] Criando novo Processing Agent com modelo {processing_model}")
+            processing_agent = ProcessingAgentManager(processing_model)
+            processing_agent_id = obj_manager.store_processing_agent(processing_agent)
+            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)
+
+        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)
+
+        # Log da resposta da primeira LLM
+        logging.info(f"[PROCESSING NODE] ===== RESPOSTA DA PRIMEIRA LLM =====")
+        logging.info(f"{processing_result.get('output', 'Sem resposta')}")
+        logging.info(f"[PROCESSING NODE] ===== FIM DA RESPOSTA =====")
+
+        if processing_result["success"]:
+            # Extrai query sugerida e observações
+            suggested_query = processing_result.get("suggested_query", "")
+            query_observations = processing_result.get("query_observations", "")
+
+            # Atualiza estado com resultados do processamento
+            state.update({
+                "suggested_query": suggested_query,
+                "query_observations": query_observations,
+                "processing_result": processing_result,
+                "processing_success": True
+            })
+            
+            # Log simples do resultado
+            if suggested_query:
+                logging.info(f"[PROCESSING NODE] ✅ Query SQL extraída com sucesso")
+                logging.info(f"[PROCESSING NODE] ✅ Observações extraídas: {len(query_observations)} caracteres")
+                logging.info(f"[PROCESSING NODE] 🎯 Query será incluída no contexto do SQL Agent")
+            else:
+                logging.warning(f"[PROCESSING NODE] ❌ Nenhuma query foi extraída - agente SQL funcionará normalmente")
+            
+        else:
+            # Em caso de erro, continua sem processamento
+            error_msg = processing_result.get("output", "Erro desconhecido")
+            logging.error(f"[PROCESSING] Erro no processamento: {error_msg}")
+
+            state.update({
+                "suggested_query": "",
+                "query_observations": "",
+                "processing_result": processing_result,
+                "processing_success": False,
+                "processing_error": error_msg
+            })
+        
+    except Exception as e:
+        error_msg = f"Erro no nó de processamento: {e}"
+        logging.error(f"[PROCESSING] {error_msg}")
+        
+        # Em caso de erro, continua sem processamento
+        state.update({
+            "suggested_query": "",
+            "query_observations": "",
+            "processing_success": False,
+            "processing_error": error_msg
+        })
+    
+    return state
+
+
+def should_use_processing(state: Dict[str, Any]) -> str:
+    """
+    Determina se deve usar o Processing Agent
+    
+    Args:
+        state: Estado atual
+        
+    Returns:
+        Nome do próximo nó
+    """
+    if state.get("processing_enabled", False):
+        return "process_initial_context"
+    else:
+        return "prepare_context"
+
+
+async def validate_processing_input_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Valida entrada para o Processing Agent
+
+    Args:
+        state: Estado atual
+
+    Returns:
+        Estado validado
+    """
+    try:
+        logging.info("[PROCESSING VALIDATION] ===== VALIDANDO ENTRADA PARA PROCESSING AGENT =====")
+
+        # Verifica se processing está habilitado
+        processing_enabled = state.get("processing_enabled", False)
+        logging.info(f"[PROCESSING VALIDATION] Processing habilitado: {processing_enabled}")
+
+        if not processing_enabled:
+            logging.info("[PROCESSING VALIDATION] Processing desabilitado - pulando validação")
+            return state
+
+        # Valida modelo de processamento
+        processing_model = state.get("processing_model", "")
+        logging.info(f"[PROCESSING VALIDATION] Modelo especificado: '{processing_model}'")
+
+        if not processing_model:
+            logging.warning("[PROCESSING VALIDATION] Modelo de processamento não especificado, usando padrão")
+            state["processing_model"] = "gpt-4o-mini"
+            logging.info(f"[PROCESSING VALIDATION] Modelo padrão definido: gpt-4o-mini")
+
+        # Valida entrada do usuário
+        user_input = state.get("user_input", "")
+        if not user_input or not user_input.strip():
+            logging.error("[PROCESSING VALIDATION] Entrada do usuário vazia - desabilitando processing")
+            state["processing_enabled"] = False
+            return state
+
+        logging.info(f"[PROCESSING VALIDATION] Validação concluída com sucesso")
+        logging.info(f"[PROCESSING VALIDATION] Modelo final: {state['processing_model']}")
+        logging.info(f"[PROCESSING VALIDATION] Entrada: {user_input[:100]}...")
+
+    except Exception as e:
+        logging.error(f"[PROCESSING VALIDATION] Erro na validação: {e}")
+        state["processing_enabled"] = False
+
+    return state

nodes/query_node.py

@@ -0,0 +1,247 @@
+"""
+Nó para processamento de consultas SQL
+"""
+import time
+import logging
+import pandas as pd
+from typing import Dict, Any, TypedDict
+
+from agents.tools import is_greeting, detect_query_type, prepare_sql_context
+from agents.sql_agent import SQLAgentManager
+from utils.object_manager import get_object_manager
+
+class QueryState(TypedDict):
+    """Estado para processamento de consultas"""
+    user_input: str
+    selected_model: str
+    response: str
+    execution_time: float
+    error: str
+    intermediate_steps: list
+    llama_instruction: str
+    sql_result: dict
+
+async def process_user_query_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó principal para processar consulta do usuário
+    
+    Args:
+        state: Estado atual com entrada do usuário
+        
+    Returns:
+        Estado atualizado com resposta processada
+    """
+    start_time = time.time()
+    user_input = state["user_input"]
+    selected_model = state["selected_model"]
+    
+    logging.info(f"[QUERY] Processando: {user_input[:50]}...")
+    
+    try:
+        # Verifica se é saudação
+        if is_greeting(user_input):
+            greeting_response = "Olá! Estou aqui para ajudar com suas consultas. Pergunte algo relacionado aos dados carregados no agente!"
+            state.update({
+                "response": greeting_response,
+                "execution_time": time.time() - start_time,
+                "error": None
+            })
+            return state
+        
+        # Recupera objetos necessários
+        obj_manager = get_object_manager()
+        
+        # Recupera cache manager
+        cache_id = state.get("cache_id")
+        cache_manager = obj_manager.get_cache_manager(cache_id) if cache_id else None
+        
+        # Verifica cache se disponível
+        if cache_manager:
+            cached_response = cache_manager.get_cached_response(user_input)
+            if cached_response:
+                logging.info(f"[CACHE] Retornando resposta do cache")
+                state.update({
+                    "response": cached_response,
+                    "execution_time": time.time() - start_time,
+                    "error": None
+                })
+                return state
+        
+        # Converte amostra do banco para DataFrame
+        db_sample_dict = state.get("db_sample_dict", {})
+        if not db_sample_dict:
+            raise ValueError("Amostra do banco não disponível")
+        
+        # Reconstrói DataFrame da amostra
+        db_sample = pd.DataFrame(db_sample_dict.get("data", []))
+        if db_sample.empty:
+            raise ValueError("Dados de amostra vazios")
+        
+        # Detecta tipo de query e prepara contexto
+        query_type = detect_query_type(user_input)
+        state["query_type"] = query_type
+
+        if query_type in ['sql_query', 'sql_query_graphic']:
+            # Obtém sugestão de query e observações do Processing Agent (se disponível)
+            suggested_query = state.get("suggested_query", "")
+            query_observations = state.get("query_observations", "")
+
+            # Prepara contexto para envio direto ao agentSQL
+            sql_context = prepare_sql_context(user_input, db_sample, suggested_query, query_observations)
+            state["sql_context"] = sql_context
+
+            logging.info(f"[DEBUG] Tipo de query detectado: {query_type}")
+            if suggested_query:
+                logging.info(f"[DEBUG] Query sugerida pelo Processing Agent incluída no contexto")
+            logging.info(f"[DEBUG] Contexto preparado para agentSQL")
+        else:
+            # Para tipos futuros (prediction)
+            error_msg = f"Tipo de query '{query_type}' ainda não implementado."
+            state.update({
+                "error": error_msg,
+                "response": error_msg,
+                "execution_time": time.time() - start_time
+            })
+            return state
+        
+        # Recupera agente SQL
+        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")
+        
+        # Executa query no agente SQL com contexto direto
+        sql_result = await sql_agent.execute_query(state["sql_context"])
+
+        # Log da resposta do agente SQL
+        logging.info(f"[AGENT SQL] ===== RESPOSTA DO AGENTE SQL =====")
+        logging.info(f"[AGENT SQL] Sucesso: {sql_result['success']}")
+        logging.info(f"[AGENT SQL] Resposta completa:")
+        logging.info(f"{sql_result.get('output', 'Sem resposta')}")
+        if sql_result.get("sql_query"):
+            logging.info(f"[AGENT SQL] Query SQL capturada: {sql_result['sql_query']}")
+        logging.info(f"[AGENT SQL] ===== FIM DA RESPOSTA =====")
+
+        if not sql_result["success"]:
+            state.update({
+                "error": sql_result["output"],
+                "response": sql_result["output"],
+                "sql_result": sql_result
+            })
+        else:
+            # Captura query SQL do resultado do agente
+            sql_query_captured = sql_result.get("sql_query")
+
+            state.update({
+                "response": sql_result["output"],
+                "intermediate_steps": sql_result["intermediate_steps"],
+                "sql_result": sql_result,
+                "sql_query_extracted": sql_query_captured,  # ← Query SQL capturada
+                "error": None
+            })
+
+            # Log apenas se não foi capturada (caso de erro)
+            if not sql_query_captured:
+                logging.warning("[QUERY] ⚠️ Nenhuma query SQL foi capturada pelo handler")
+        
+        # Armazena no cache se disponível
+        if cache_manager and sql_result["success"]:
+            cache_manager.cache_response(user_input, state["response"])
+        
+        state["execution_time"] = time.time() - start_time
+        logging.info(f"[QUERY] Concluído em {state['execution_time']:.2f}s")
+        
+    except Exception as e:
+        error_msg = f"Erro ao processar query: {e}"
+        logging.error(f"[QUERY] {error_msg}")
+        state.update({
+            "error": error_msg,
+            "response": error_msg,
+            "execution_time": time.time() - start_time
+        })
+    
+    return state
+
+async def validate_query_input_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para validar entrada da consulta
+    
+    Args:
+        state: Estado com entrada do usuário
+        
+    Returns:
+        Estado atualizado com validação
+    """
+    user_input = state.get("user_input", "").strip()
+    
+    if not user_input:
+        state.update({
+            "error": "Entrada vazia",
+            "response": "Por favor, digite uma pergunta.",
+            "execution_time": 0.0
+        })
+        return state
+    
+    if len(user_input) > 1000:
+        state.update({
+            "error": "Entrada muito longa",
+            "response": "Pergunta muito longa. Por favor, seja mais conciso.",
+            "execution_time": 0.0
+        })
+        return state
+    
+    # Validação passou
+    state["error"] = None
+    logging.info(f"[VALIDATION] Entrada validada: {len(user_input)} caracteres")
+    
+    return state
+
+async def prepare_query_context_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para preparar contexto da consulta
+    
+    Args:
+        state: Estado atual
+        
+    Returns:
+        Estado com contexto preparado
+    """
+    try:
+        # Verifica se todos os componentes necessários estão disponíveis
+        required_ids = ["agent_id", "engine_id", "cache_id"]
+        missing_ids = [id_name for id_name in required_ids if not state.get(id_name)]
+        
+        if missing_ids:
+            raise ValueError(f"IDs necessários não encontrados: {missing_ids}")
+        
+        obj_manager = get_object_manager()
+        
+        # Verifica se objetos existem
+        for id_name in required_ids:
+            obj_id = state[id_name]
+            if id_name == "agent_id":
+                obj = obj_manager.get_sql_agent(obj_id)
+            elif id_name == "engine_id":
+                obj = obj_manager.get_engine(obj_id)
+            elif id_name == "cache_id":
+                obj = obj_manager.get_cache_manager(obj_id)
+            
+            if obj is None:
+                raise ValueError(f"Objeto não encontrado para {id_name}: {obj_id}")
+        
+        # Contexto preparado com sucesso
+        state["context_ready"] = True
+        logging.info("[CONTEXT] Contexto da consulta preparado")
+        
+    except Exception as e:
+        error_msg = f"Erro ao preparar contexto: {e}"
+        logging.error(f"[CONTEXT] {error_msg}")
+        state.update({
+            "error": error_msg,
+            "context_ready": False
+        })
+    
+    return state

nodes/refinement_node.py

@@ -0,0 +1,141 @@
+"""
+Nó para refinamento de respostas
+"""
+import logging
+from typing import Dict, Any
+
+from agents.tools import refine_response_with_llm
+
+async def refine_response_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para refinar a resposta usando LLM adicional
+    
+    Args:
+        state: Estado atual do agente
+        
+    Returns:
+        Estado atualizado com resposta refinada
+    """
+    if not state.get("advanced_mode", False) or state.get("error"):
+        # Pula refinamento se modo avançado desabilitado ou há erro
+        logging.info("[REFINE] Pulando refinamento - modo avançado desabilitado ou erro presente")
+        return state
+    
+    logging.info("[REFINE] Iniciando refinamento da resposta")
+    
+    try:
+        original_response = state.get("response", "")
+        user_input = state.get("user_input", "")
+        
+        if not original_response or not user_input:
+            logging.warning("[REFINE] Resposta ou entrada do usuário não disponível")
+            return state
+        
+        # Refina resposta com LLM adicional
+        refined_response = await refine_response_with_llm(
+            user_input,
+            original_response
+        )
+        
+        # Atualiza estado com resposta refinada
+        state["response"] = refined_response
+        state["refined"] = True
+        
+        logging.info("[REFINE] Resposta refinada com sucesso")
+        
+    except Exception as e:
+        error_msg = f"Erro ao refinar resposta: {e}"
+        logging.error(f"[REFINE] {error_msg}")
+        # Mantém resposta original em caso de erro
+        state["refinement_error"] = error_msg
+    
+    return state
+
+async def check_refinement_quality_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para verificar qualidade do refinamento
+    
+    Args:
+        state: Estado com resposta refinada
+        
+    Returns:
+        Estado com avaliação da qualidade
+    """
+    try:
+        original_response = state.get("sql_result", {}).get("output", "")
+        refined_response = state.get("response", "")
+        
+        if not state.get("refined", False):
+            state["refinement_quality"] = "not_refined"
+            return state
+        
+        # Métricas simples de qualidade
+        quality_metrics = {
+            "length_increase": len(refined_response) - len(original_response),
+            "has_insights": any(word in refined_response.lower() for word in [
+                "insight", "análise", "interpretação", "conclusão", "tendência"
+            ]),
+            "has_statistics": any(word in refined_response.lower() for word in [
+                "média", "total", "percentual", "proporção", "estatística"
+            ]),
+            "improved": len(refined_response) > len(original_response) * 1.1
+        }
+        
+        # Determina qualidade geral
+        if quality_metrics["improved"] and (quality_metrics["has_insights"] or quality_metrics["has_statistics"]):
+            quality_score = "high"
+        elif quality_metrics["length_increase"] > 0:
+            quality_score = "medium"
+        else:
+            quality_score = "low"
+        
+        state["refinement_quality"] = quality_score
+        state["quality_metrics"] = quality_metrics
+        
+        logging.info(f"[REFINE] Qualidade avaliada: {quality_score}")
+        
+    except Exception as e:
+        logging.error(f"[REFINE] Erro ao avaliar qualidade: {e}")
+        state["refinement_quality"] = "error"
+    
+    return state
+
+async def format_final_response_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para formatação final da resposta
+    
+    Args:
+        state: Estado com resposta processada
+        
+    Returns:
+        Estado com resposta formatada
+    """
+    try:
+        response = state.get("response", "")
+        execution_time = state.get("execution_time", 0.0)
+        advanced_mode = state.get("advanced_mode", False)
+        refined = state.get("refined", False)
+        
+        # Adiciona informações de contexto se necessário
+        if advanced_mode and refined:
+            quality = state.get("refinement_quality", "unknown")
+            if quality == "high":
+                response += "\n\n💡 *Resposta aprimorada com análise avançada*"
+            elif quality == "medium":
+                response += "\n\n🔍 *Resposta complementada*"
+        
+        # Adiciona tempo de execução se significativo
+        if execution_time > 2.0:
+            response += f"\n\n⏱️ *Processado em {execution_time:.1f}s*"
+        
+        # Formatação final
+        state["response"] = response.strip()
+        state["formatted"] = True
+        
+        logging.info(f"[FORMAT] Resposta formatada - {len(response)} caracteres")
+        
+    except Exception as e:
+        logging.error(f"[FORMAT] Erro na formatação: {e}")
+        # Mantém resposta original se houver erro na formatação
+    
+    return state

requirements.txt

@@ -0,0 +1,28 @@
+# Core LangGraph and LangChain
+langgraph>=0.2.0
+langchain>=0.3.0
+langchain-openai>=0.2.0
+langchain-anthropic>=0.2.0
+langchain-community>=0.3.0
+langchain-core>=0.3.0
+
+# LangSmith for observability and tracing
+langsmith>=0.1.39
+
+# Database and Data Processing
+pandas>=2.0.0
+sqlalchemy>=2.0.0
+numpy>=1.24.0
+
+# AI/ML Libraries
+huggingface_hub>=0.20.0
+
+# Graph Generation Libraries
+matplotlib>=3.7.0
+pillow>=10.0.0
+
+# Web Interface
+gradio>=4.0.0
+
+# Utilities
+python-dotenv>=1.0.0

tabela.csv

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:de0091898b8e75943617f2116e621dbbea7be1232659b93a3a8b23a3114f2ac3
-size 162333121

utils/config.py

@@ -0,0 +1,180 @@
+"""
+Configurações e constantes do projeto AgentGraph
+"""
+import os
+from dotenv import load_dotenv
+import logging
+
+# Carrega variáveis de ambiente
+load_dotenv()
+
+# Configurações de API
+HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")
+
+# Configurações do LangSmith (observabilidade)
+LANGSMITH_API_KEY = os.getenv("LANGSMITH_API_KEY")
+LANGSMITH_TRACING = os.getenv("LANGSMITH_TRACING", "false").lower() == "true"
+LANGSMITH_ENDPOINT = os.getenv("LANGSMITH_ENDPOINT", "https://api.smith.langchain.com")
+LANGSMITH_PROJECT = os.getenv("LANGSMITH_PROJECT", "agentgraph-project")
+
+# Configurações de arquivos e diretórios
+UPLOAD_DIR = os.getenv("UPLOAD_DIR", "uploaded_data")
+DEFAULT_CSV_PATH = os.getenv("DEFAULT_CSV_PATH", "tabela.csv")
+SQL_DB_PATH = os.getenv("SQL_DB_PATH", "data.db")
+UPLOADED_CSV_PATH = os.path.join(UPLOAD_DIR, "tabela.csv")
+
+# Modelos disponíveis para seleção (usados no agentSQL)
+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"
+}
+
+# Modelos para refinamento (apenas uso interno)
+REFINEMENT_MODELS = {
+    "LLaMA 70B": "meta-llama/Llama-3.3-70B-Instruct",
+    "LlaMA 8B": "meta-llama/Llama-3.1-8B-Instruct",
+    "DeepSeek-R1": "deepseek-ai/DeepSeek-R1-0528"
+}
+
+# Mapeamento completo de modelos (para compatibilidade)
+LLAMA_MODELS = {**AVAILABLE_MODELS, **REFINEMENT_MODELS}
+
+MAX_TOKENS_MAP = {
+    # Modelos de refinamento
+    "meta-llama/Llama-3.3-70B-Instruct": 900,
+    "meta-llama/Llama-3.1-8B-Instruct": 700,
+    "deepseek-ai/DeepSeek-R1-0528": 8192,
+    # Modelos do agentSQL
+    "o3-mini": 4096,
+    "gpt-4o-mini": 4096,
+    "gpt-4o": 4096,
+    "claude-3-5-sonnet-20241022": 1024
+}
+
+# Modelos que usam OpenAI (GPT)
+OPENAI_MODELS = {
+    "o3-mini",
+    "gpt-4o-mini",
+    "gpt-4o",
+}
+
+# Modelos que usam Anthropic (Claude)
+ANTHROPIC_MODELS = {
+    "claude-3-5-sonnet-20241022"
+}
+
+# Modelos que usam HuggingFace (para refinamento)
+HUGGINGFACE_MODELS = {
+    "meta-llama/Llama-3.3-70B-Instruct",
+    "meta-llama/Llama-3.1-8B-Instruct",
+    "deepseek-ai/DeepSeek-R1-0528"
+}
+
+# Configurações do agente
+DEFAULT_MODEL = os.getenv("DEFAULT_MODEL", "GPT-4o-mini")
+MAX_ITERATIONS = int(os.getenv("MAX_ITERATIONS", "40"))
+TEMPERATURE = float(os.getenv("TEMPERATURE", "0"))
+
+# Configurações do Gradio
+GRADIO_SHARE = os.getenv("GRADIO_SHARE", "False").lower() == "true"
+GRADIO_PORT = int(os.getenv("GRADIO_PORT", "7860"))
+
+# Configurações de logging
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+
+# Configuração do logging
+logging.basicConfig(
+    level=getattr(logging, LOG_LEVEL.upper()),
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+
+# Cria diretório de upload se não existir
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+# Configuração das variáveis de ambiente para OpenAI
+if OPENAI_API_KEY:
+    os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+
+# Configuração das variáveis de ambiente para Anthropic
+if ANTHROPIC_API_KEY:
+    os.environ["ANTHROPIC_API_KEY"] = ANTHROPIC_API_KEY
+
+# Configuração das variáveis de ambiente para LangSmith
+if LANGSMITH_API_KEY:
+    os.environ["LANGSMITH_API_KEY"] = LANGSMITH_API_KEY
+    os.environ["LANGSMITH_TRACING"] = str(LANGSMITH_TRACING).lower()
+    os.environ["LANGSMITH_ENDPOINT"] = LANGSMITH_ENDPOINT
+    os.environ["LANGSMITH_PROJECT"] = LANGSMITH_PROJECT
+    logging.info(f"LangSmith configurado: projeto='{LANGSMITH_PROJECT}', tracing={LANGSMITH_TRACING}")
+else:
+    logging.info("LangSmith não configurado (LANGSMITH_API_KEY não encontrada)")
+
+def get_active_csv_path():
+    """Retorna o CSV ativo: o carregado ou o padrão."""
+    if os.path.exists(UPLOADED_CSV_PATH):
+        logging.info(f"[CSV] Usando arquivo CSV carregado: {UPLOADED_CSV_PATH}")
+        return UPLOADED_CSV_PATH
+    else:
+        logging.info(f"[CSV] Usando arquivo CSV padrão: {DEFAULT_CSV_PATH}")
+        return DEFAULT_CSV_PATH
+
+def validate_config():
+    """Valida se as configurações necessárias estão presentes."""
+    errors = []
+    warnings = []
+
+    if not HUGGINGFACE_API_KEY:
+        errors.append("HUGGINGFACE_API_KEY não configurada")
+
+    if not OPENAI_API_KEY:
+        errors.append("OPENAI_API_KEY não configurada")
+
+    if not ANTHROPIC_API_KEY:
+        errors.append("ANTHROPIC_API_KEY não configurada")
+
+    if not os.path.exists(DEFAULT_CSV_PATH):
+        errors.append(f"Arquivo CSV padrão não encontrado: {DEFAULT_CSV_PATH}")
+
+    # LangSmith é opcional - apenas aviso se não configurado
+    if not LANGSMITH_API_KEY:
+        warnings.append("LANGSMITH_API_KEY não configurada - observabilidade desabilitada")
+
+    if errors:
+        raise ValueError(f"Erros de configuração: {', '.join(errors)}")
+
+    if warnings:
+        for warning in warnings:
+            logging.warning(warning)
+
+    logging.info("Configurações validadas com sucesso")
+    return True
+
+def is_langsmith_enabled() -> bool:
+    """
+    Verifica se o LangSmith está habilitado e configurado
+
+    Returns:
+        True se LangSmith estiver habilitado, False caso contrário
+    """
+    return bool(LANGSMITH_API_KEY and LANGSMITH_TRACING)
+
+def get_langsmith_metadata() -> dict:
+    """
+    Retorna metadados padrão para traces do LangSmith
+
+    Returns:
+        Dicionário com metadados do projeto
+    """
+    if not is_langsmith_enabled():
+        return {}
+
+    return {
+        "project": LANGSMITH_PROJECT,
+        "application": "AgentGraph",
+        "version": "1.0.0",
+        "environment": "production"
+    }

utils/database.py

@@ -0,0 +1,93 @@
+"""
+Funções para gerenciamento de banco de dados e processamento de CSV
+"""
+import os
+import pandas as pd
+from sqlalchemy import create_engine
+from sqlalchemy.types import DateTime, Integer, Float
+from langchain_community.utilities import SQLDatabase
+import logging
+from typing import Optional
+
+from utils.config import SQL_DB_PATH
+
+# FUNÇÃO REMOVIDA: create_engine_and_load_db
+# Esta função foi substituída pela nova arquitetura de nós
+# Use: csv_processing_node.py + database_node.py
+
+def create_engine_from_processed_dataframe(processed_df: pd.DataFrame, sql_types: dict, sql_db_path: str = SQL_DB_PATH):
+    """
+    Cria engine SQLAlchemy a partir de DataFrame já processado
+    NOVA VERSÃO - usa processamento genérico
+
+    Args:
+        processed_df: DataFrame já processado
+        sql_types: Dicionário com tipos SQL para as colunas
+        sql_db_path: Caminho para o banco SQLite
+
+    Returns:
+        SQLAlchemy Engine
+    """
+    logging.info("Criando banco de dados a partir de DataFrame processado...")
+    engine = create_engine(f"sqlite:///{sql_db_path}")
+
+    logging.info("[DEBUG] Tipos das colunas processadas:")
+    logging.info(processed_df.dtypes)
+
+    # Salva no banco SQLite
+    processed_df.to_sql("tabela", engine, index=False, if_exists="replace", dtype=sql_types)
+    logging.info(f"Banco de dados SQL criado com sucesso! {len(processed_df)} registros salvos")
+    return engine
+
+def create_sql_database(engine) -> SQLDatabase:
+    """
+    Cria objeto SQLDatabase do LangChain a partir de uma engine
+    
+    Args:
+        engine: SQLAlchemy Engine
+        
+    Returns:
+        SQLDatabase do LangChain
+    """
+    return SQLDatabase(engine=engine)
+
+def get_sample_data(engine, limit: int = 10) -> pd.DataFrame:
+    """
+    Obtém dados de amostra do banco para contexto
+    
+    Args:
+        engine: SQLAlchemy Engine
+        limit: Número de linhas para retornar
+        
+    Returns:
+        DataFrame com dados de amostra
+    """
+    try:
+        return pd.read_sql_query(f"SELECT * FROM tabela LIMIT {limit}", engine)
+    except Exception as e:
+        logging.error(f"Erro ao obter dados de amostra: {e}")
+        return pd.DataFrame()
+
+def validate_database(engine) -> bool:
+    """
+    Valida se o banco de dados está funcionando corretamente
+    
+    Args:
+        engine: SQLAlchemy Engine
+        
+    Returns:
+        True se válido, False caso contrário
+    """
+    try:
+        # Testa uma query simples
+        result = pd.read_sql_query("SELECT COUNT(*) as count FROM tabela", engine)
+        count = result.iloc[0]['count']
+        logging.info(f"Banco validado: {count} registros encontrados")
+        return count > 0
+    except Exception as e:
+        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

@@ -0,0 +1,159 @@
+"""
+Gerenciador de objetos não-serializáveis para LangGraph
+"""
+import uuid
+from typing import Dict, Any, Optional
+import logging
+
+class ObjectManager:
+    """
+    Gerencia objetos não-serializáveis que não podem ser incluídos no estado do LangGraph
+    """
+    
+    def __init__(self):
+        self._objects: Dict[str, Any] = {}
+        self._sql_agents: Dict[str, Any] = {}
+        self._processing_agents: Dict[str, Any] = {}
+        self._engines: Dict[str, Any] = {}
+        self._databases: Dict[str, Any] = {}
+        self._cache_managers: Dict[str, Any] = {}
+        # Mapeamento para relacionar agentes com seus bancos
+        self._agent_db_mapping: Dict[str, str] = {}
+    
+    def store_sql_agent(self, agent: Any, db_id: str = None) -> str:
+        """Armazena agente SQL e retorna ID"""
+        agent_id = str(uuid.uuid4())
+        self._sql_agents[agent_id] = agent
+
+        # Mapeia agente com seu banco se fornecido
+        if db_id:
+            self._agent_db_mapping[agent_id] = db_id
+
+        logging.info(f"Agente SQL armazenado com ID: {agent_id}")
+        return agent_id
+    
+    def get_sql_agent(self, agent_id: str) -> Optional[Any]:
+        """Recupera agente SQL pelo ID"""
+        return self._sql_agents.get(agent_id)
+
+    def store_processing_agent(self, agent: Any) -> str:
+        """Armazena Processing Agent e retorna ID"""
+        agent_id = str(uuid.uuid4())
+        self._processing_agents[agent_id] = agent
+        logging.info(f"Processing Agent armazenado com ID: {agent_id}")
+        return agent_id
+
+    def get_processing_agent(self, agent_id: str) -> Optional[Any]:
+        """Recupera Processing Agent pelo ID"""
+        return self._processing_agents.get(agent_id)
+    
+    def store_engine(self, engine: Any) -> str:
+        """Armazena engine e retorna ID"""
+        engine_id = str(uuid.uuid4())
+        self._engines[engine_id] = engine
+        logging.info(f"Engine armazenada com ID: {engine_id}")
+        return engine_id
+    
+    def get_engine(self, engine_id: str) -> Optional[Any]:
+        """Recupera engine pelo ID"""
+        return self._engines.get(engine_id)
+
+    def store_database(self, database: Any) -> str:
+        """Armazena banco de dados e retorna ID"""
+        db_id = str(uuid.uuid4())
+        self._databases[db_id] = database
+        logging.info(f"Banco de dados armazenado com ID: {db_id}")
+        return db_id
+
+    def get_database(self, db_id: str) -> Optional[Any]:
+        """Recupera banco de dados pelo ID"""
+        return self._databases.get(db_id)
+
+    def get_db_id_for_agent(self, agent_id: str) -> Optional[str]:
+        """Recupera ID do banco associado ao agente"""
+        return self._agent_db_mapping.get(agent_id)
+    
+    def store_cache_manager(self, cache_manager: Any) -> str:
+        """Armazena cache manager e retorna ID"""
+        cache_id = str(uuid.uuid4())
+        self._cache_managers[cache_id] = cache_manager
+        logging.info(f"Cache manager armazenado com ID: {cache_id}")
+        return cache_id
+    
+    def get_cache_manager(self, cache_id: str) -> Optional[Any]:
+        """Recupera cache manager pelo ID"""
+        return self._cache_managers.get(cache_id)
+    
+    def store_object(self, obj: Any, category: str = "general") -> str:
+        """Armazena objeto genérico e retorna ID"""
+        obj_id = str(uuid.uuid4())
+        self._objects[obj_id] = {"object": obj, "category": category}
+        logging.info(f"Objeto {category} armazenado com ID: {obj_id}")
+        return obj_id
+    
+    def get_object(self, obj_id: str) -> Optional[Any]:
+        """Recupera objeto pelo ID"""
+        obj_data = self._objects.get(obj_id)
+        return obj_data["object"] if obj_data else None
+    
+    def update_sql_agent(self, agent_id: str, new_agent: Any) -> bool:
+        """Atualiza agente SQL existente"""
+        if agent_id in self._sql_agents:
+            self._sql_agents[agent_id] = new_agent
+            logging.info(f"Agente SQL atualizado: {agent_id}")
+            return True
+        return False
+    
+    def update_engine(self, engine_id: str, new_engine: Any) -> bool:
+        """Atualiza engine existente"""
+        if engine_id in self._engines:
+            self._engines[engine_id] = new_engine
+            logging.info(f"Engine atualizada: {engine_id}")
+            return True
+        return False
+    
+    def update_cache_manager(self, cache_id: str, new_cache_manager: Any) -> bool:
+        """Atualiza cache manager existente"""
+        if cache_id in self._cache_managers:
+            self._cache_managers[cache_id] = new_cache_manager
+            logging.info(f"Cache manager atualizado: {cache_id}")
+            return True
+        return False
+    
+    def clear_all(self):
+        """Limpa todos os objetos armazenados"""
+        self._objects.clear()
+        self._sql_agents.clear()
+        self._engines.clear()
+        self._databases.clear()
+        self._cache_managers.clear()
+        self._agent_db_mapping.clear()
+        logging.info("Todos os objetos foram limpos do gerenciador")
+    
+    def get_stats(self) -> Dict[str, int]:
+        """Retorna estatísticas dos objetos armazenados"""
+        return {
+            "sql_agents": len(self._sql_agents),
+            "engines": len(self._engines),
+            "databases": len(self._databases),
+            "cache_managers": len(self._cache_managers),
+            "general_objects": len(self._objects),
+            "agent_db_mappings": len(self._agent_db_mapping)
+        }
+
+# Instância global do gerenciador
+_object_manager: Optional[ObjectManager] = None
+
+def get_object_manager() -> ObjectManager:
+    """Retorna instância singleton do gerenciador de objetos"""
+    global _object_manager
+    if _object_manager is None:
+        _object_manager = ObjectManager()
+    return _object_manager
+
+def reset_object_manager():
+    """Reseta o gerenciador de objetos"""
+    global _object_manager
+    if _object_manager:
+        _object_manager.clear_all()
+    _object_manager = ObjectManager()