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

ARCHITECTURE.md

@@ -0,0 +1,418 @@
+# 🏗️ AgentGraph - Arquitetura Técnica Detalhada
+
+## 🎯 Visão Geral
+
+O AgentGraph é uma **plataforma multi-agente** construída com LangGraph, implementando uma arquitetura modular e extensível baseada em nós especializados. O sistema suporta múltiplos provedores LLM (OpenAI, Anthropic, HuggingFace) com processamento assíncrono, gerenciamento inteligente de objetos não-serializáveis e sistema robusto de retry para rate limiting.
+
+### **Principais Inovações Arquiteturais**
+- 🔄 **Fluxo Otimizado**: Detecção → AgentSQL → Refinamento (sem LLM intermediária)
+- 🧠 **Multi-Provedor**: Suporte nativo a OpenAI, Anthropic e HuggingFace
+- 🛠️ **Tool-Calling**: Ferramentas SQL nativas with verbose ativo
+- 🎛️ **Object Manager**: Solução elegante para objetos não-serializáveis
+- ⚡ **Async/Await**: Processamento não-bloqueante em toda a stack
+- 🔍 **LangSmith Integration**: Observabilidade completa com rastreamento automático
+
+## 📁 Estrutura do Projeto
+
+```
+agentgraph/
+├── app.py                     # Entry point: Gradio + LangGraph
+├── graphs/
+│   └── main_graph.py          # StateGraph principal
+├── nodes/                     # Nós especializados
+│   ├── csv_processing_node.py # Processamento genérico de CSV
+│   ├── database_node.py       # Operações de banco de dados
+│   ├── query_node.py          # Processamento de consultas
+│   ├── refinement_node.py     # Refinamento de respostas
+│   ├── cache_node.py          # Gerenciamento de cache
+│   ├── agent_node.py          # Coordenação geral
+│   └── custom_nodes.py        # Nós especializados
+├── agents/
+│   ├── sql_agent.py           # Criação do agente SQL
+│   └── tools.py               # Ferramentas do agente
+├── utils/
+│   ├── database.py            # Funções de banco de dados
+│   ├── config.py              # Configurações
+│   └── object_manager.py      # Gerenciador de objetos não-serializáveis
+├── uploaded_data/             # Arquivos CSV enviados
+├── requirements.txt
+├── README.md
+├── ARCHITECTURE.md
+└── .env
+```
+
+## 🔄 Fluxo do LangGraph
+
+### Fluxo Principal de Consulta
+
+```mermaid
+graph TD
+    A[validate_input] --> B[check_cache]
+    B --> C{Cache Hit?}
+    C -->|Sim| H[update_history]
+    C -->|Não| D[prepare_context]
+    D --> E[get_db_sample]
+    E --> F[process_query]
+    F --> G{Modo Avançado?}
+    G -->|Sim| I[refine_response]
+    G -->|Não| J[cache_response]
+    I --> K[format_response]
+    K --> J
+    J --> H
+    H --> L[END]
+```
+
+### Nós Especializados
+
+#### 1. **csv_processing_node.py**
+- **Função**: Processamento genérico de CSV
+- **Características**:
+  - Detecção automática de separadores (`;`, `,`, `\t`, `|`)
+  - Identificação inteligente de tipos de dados
+  - Conversão robusta para SQL types
+  - Estatísticas de processamento
+
+#### 2. **database_node.py**
+- **Função**: Operações de banco de dados
+- **Características**:
+  - Criação de banco a partir de DataFrame processado
+  - Carregamento de banco existente
+  - Obtenção de amostras de dados
+  - Validação de integridade
+
+#### 3. **query_node.py**
+- **Função**: Processamento de consultas SQL
+- **Características**:
+  - Validação de entrada
+  - Preparação de contexto
+  - Execução via agente SQL
+  - Tratamento de erros
+
+#### 4. **refinement_node.py**
+- **Função**: Refinamento de respostas
+- **Características**:
+  - Modo avançado com LLM adicional
+  - Avaliação de qualidade
+  - Formatação final
+  - Adição de insights
+
+#### 5. **cache_node.py**
+- **Função**: Gerenciamento de cache e histórico
+- **Características**:
+  - Verificação de cache
+  - Armazenamento de respostas
+  - Atualização de histórico
+  - Estatísticas de uso
+
+## 🔍 Integração LangSmith
+
+### **Observabilidade Automática**
+O AgentGraph inclui integração completa com LangSmith para rastreamento e monitoramento:
+
+```python
+# Configuração automática via variáveis de ambiente
+LANGSMITH_TRACING=true
+LANGSMITH_API_KEY=lsv2_pt_...
+LANGSMITH_PROJECT=agentgraph-project
+
+# Rastreamento automático de todo o fluxo LangGraph
+workflow.invoke(state) # ← Automaticamente rastreado
+```
+
+### **Componentes Rastreados**
+- ✅ **Todos os nós LangGraph**: validate_input → process_query → cache_response
+- ✅ **Agentes SQL**: Chamadas LLM com inputs/outputs completos
+- ✅ **Modelos Multi-Provedor**: OpenAI, Anthropic, HuggingFace
+- ✅ **Operações de Dados**: CSV processing, database operations
+- ✅ **Geração de Gráficos**: Seleção e criação de visualizações
+
+### **Benefícios da Integração**
+- 🔍 **Debug Avançado**: Visualize fluxo completo de execução
+- 📊 **Métricas de Performance**: Latência por nó e operação
+- 💰 **Análise de Custos**: Uso de tokens por modelo
+- 🐛 **Troubleshooting**: Identifique gargalos e erros
+- 📈 **Dashboards**: Monitoramento em tempo real
+
+## 🧠 Gerenciador de Objetos
+
+### Problema Resolvido
+O LangGraph requer que o estado seja serializável, mas objetos como SQLAgentManager, Engine e CacheManager não são serializáveis.
+
+### Solução: ObjectManager
+```python
+# Armazena objetos não-serializáveis
+agent_id = object_manager.store_sql_agent(sql_agent)
+engine_id = object_manager.store_engine(engine)
+cache_id = object_manager.store_cache_manager(cache_manager)
+
+# Estado serializável
+state = {
+    "user_input": "query",
+    "agent_id": agent_id,
+    "engine_id": engine_id,
+    "cache_id": cache_id
+}
+
+# Recupera objetos quando necessário
+sql_agent = object_manager.get_sql_agent(agent_id)
+```
+
+## 📊 Processamento CSV Genérico
+
+### Detecção Automática de Tipos
+
+```python
+# Detecta automaticamente:
+- Datas: Tenta conversão com pd.to_datetime()
+- Números inteiros: Verifica padrões numéricos
+- Números decimais: Detecta pontos/vírgulas
+- Texto: Mantém como string
+
+# Regras de processamento:
+- parse_dates: Para colunas de data
+- convert_to_int: Para números inteiros
+- convert_to_float: Para números decimais
+- convert_text_to_int/float: Para texto numérico
+- keep_as_text: Para texto puro
+```
+
+### Separadores Suportados
+- `;` (ponto e vírgula)
+- `,` (vírgula)
+- `\t` (tab)
+- `|` (pipe)
+
+## 🔧 Configurações
+
+### Arquivo .env
+```env
+# API Keys
+HUGGINGFACE_API_KEY=your_key_here
+OPENAI_API_KEY=your_key_here
+ANTHROPIC_API_KEY=your_key_here
+
+# LangSmith - Observabilidade (OPCIONAL)
+LANGSMITH_API_KEY=lsv2_pt_your_key_here
+LANGSMITH_TRACING=true
+LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+LANGSMITH_PROJECT=agentgraph-project
+
+# Database Configuration
+SQL_DB_PATH=data.db
+DEFAULT_CSV_PATH=tabela.csv
+UPLOAD_DIR=uploaded_data
+
+# Model Configuration
+DEFAULT_MODEL=GPT-4o-mini
+MAX_ITERATIONS=40
+TEMPERATURE=0
+
+# Gradio Configuration
+GRADIO_SHARE=False
+GRADIO_PORT=7860
+```
+
+## 🚀 Funcionalidades
+
+### ✅ Mantidas do Código Original
+- Múltiplos modelos LLM (LLaMA 70B, 8B, Qwen 32B)
+- Upload de CSV personalizado
+- Sistema de cache inteligente
+- Modo avançado com refinamento
+- Histórico de conversas
+- Interface Gradio moderna
+- Reset do sistema
+
+### ✅ Novas Funcionalidades
+- Processamento genérico de CSV
+- Arquitetura modular de nós
+- Gerenciamento de objetos não-serializáveis
+- Fluxo condicional otimizado
+- Validação automática de sistema
+- Detecção automática de portas
+- Logs estruturados
+- **Integração LangSmith**: Observabilidade completa e automática
+
+## 🧪 Testes
+
+### Arquivo de Teste
+```bash
+python test_new_architecture.py
+```
+
+Testa individualmente:
+- Processamento CSV
+- Criação de banco
+- Agente SQL
+- Gerenciador de objetos
+- Amostra de dados
+
+## 🔄 Deploy
+
+### Local
+```bash
+python app.py
+```
+
+### HuggingFace Spaces
+1. Configure as variáveis de ambiente
+2. Faça upload dos arquivos
+3. O sistema detectará automaticamente a porta disponível
+
+## 📈 Benefícios da Nova Arquitetura
+
+1. **Escalabilidade**: Fácil adição de novos nós
+2. **Manutenibilidade**: Código organizado e modular
+3. **Robustez**: Sem problemas de serialização
+4. **Flexibilidade**: Processamento genérico de dados
+5. **Performance**: Fluxo otimizado com cache
+6. **Debugging**: Logs detalhados por nó
+7. **Testabilidade**: Nós independentes testáveis
+
+## 🔍 Monitoramento
+
+### Logs Estruturados
+```
+[VALIDATION] - Validação de entrada
+[CACHE] - Operações de cache
+[CONTEXT] - Preparação de contexto
+[DATABASE] - Operações de banco
+[QUERY] - Processamento de consultas
+[REFINE] - Refinamento de respostas
+[HISTORY] - Atualização de histórico
+```
+
+### Estatísticas
+- Tempo de execução por nó
+- Taxa de acerto do cache
+- Estatísticas de processamento CSV
+- Validação de componentes
+
+## 🚀 Roadmap de Expansão
+
+### **🎯 Arquitetura Preparada para Múltiplos Agentes**
+
+A arquitetura atual está **perfeitamente preparada** para expansão com novos agentes especializados:
+
+#### **📄 Agente PDF (Curto Prazo)**
+```python
+# Implementação planejada:
+nodes/pdf_processing_node.py
+agents/pdf_agent.py
+
+# Funcionalidades:
+- Extração de texto (PyPDF2, pdfplumber)
+- OCR para documentos escaneados (Tesseract)
+- Análise de estrutura de documentos
+- Busca semântica em conteúdo
+- Integração com LangGraph existente
+```
+
+#### **🗄️ Agente MySQL (Médio Prazo)**
+```python
+# Implementação planejada:
+nodes/mysql_node.py
+agents/mysql_agent.py
+
+# Funcionalidades:
+- Conexões externas MySQL/PostgreSQL
+- Pool de conexões otimizado
+- Queries complexas com JOINs
+- Transações e rollbacks
+- Múltiplas bases de dados
+```
+
+#### **📊 Agente de Gráficos (Médio Prazo)**
+```python
+# Implementação planejada:
+nodes/chart_generation_node.py
+agents/chart_agent.py
+
+# Funcionalidades:
+- Matplotlib, Plotly, Seaborn
+- Gráficos baseados em consultas SQL
+- Análise automática de dados
+- Exporta��ão em múltiplos formatos
+- Dashboards interativos
+```
+
+#### **🤖 Agente de ML/Previsões (Longo Prazo)**
+```python
+# Implementação planejada:
+nodes/prediction_node.py
+agents/ml_agent.py
+
+# Funcionalidades:
+- Modelos de Machine Learning
+- Análise de séries temporais
+- Previsões automáticas
+- Integração com scikit-learn
+- AutoML capabilities
+```
+
+### **🔄 Sistema de Detecção Expandido**
+
+```python
+def detect_query_type(user_query: str) -> str:
+    """Função já preparada para expansão"""
+
+    query_lower = user_query.lower().strip()
+
+    # Detecção atual
+    if 'sql' in query_lower or 'tabela' in query_lower:
+        return 'sql_query'
+
+    # Expansões futuras (já estruturadas)
+    elif 'pdf' in query_lower or 'documento' in query_lower:
+        return 'pdf_processing'
+    elif 'mysql' in query_lower or 'banco mysql' in query_lower:
+        return 'mysql_query'
+    elif 'gráfico' in query_lower or 'chart' in query_lower:
+        return 'chart_generation'
+    elif 'prever' in query_lower or 'previsão' in query_lower:
+        return 'prediction'
+
+    return 'sql_query'  # Default
+```
+
+### **🎛️ Roteamento Condicional Preparado**
+
+```python
+# No main_graph.py - Estrutura já preparada
+def route_by_type(state: Dict[str, Any]) -> str:
+    query_type = state.get("query_type", "sql_query")
+
+    routing_map = {
+        "sql_query": "sql_processing",
+        "pdf_processing": "pdf_processing",      # FUTURO
+        "mysql_query": "mysql_processing",       # FUTURO
+        "chart_generation": "chart_generation",  # FUTURO
+        "prediction": "prediction_processing"    # FUTURO
+    }
+
+    return routing_map.get(query_type, "sql_processing")
+```
+
+### **📈 Facilidade de Implementação**
+
+**Por que é fácil expandir:**
+- ✅ **Estrutura modular** - Cada agente = novo nó
+- ✅ **ObjectManager flexível** - Gerencia qualquer objeto
+- ✅ **Sistema de detecção** - Já preparado para novos tipos
+- ✅ **Configurações centralizadas** - Fácil adicionar APIs
+- ✅ **Interface dinâmica** - Dropdown automático
+- ✅ **Async/await** - Performance mantida
+- ✅ **Logs estruturados** - Debugging facilitado
+
+### **🎯 Próximos Passos Recomendados**
+
+1. **Agente PDF** - Implementação mais simples e útil
+2. **Sistema de Templates** - Prompts especializados por agente
+3. **Métricas avançadas** - Performance por tipo de agente
+4. **API REST** - Exposição de funcionalidades
+5. **Agente MySQL** - Conexões externas
+6. **Sistema de Pipelines** - Combinação de agentes
+
+---
+
+**🏆 Conclusão**: A arquitetura atual é **excepcional** e está perfeitamente preparada para se tornar uma **plataforma completa de agentes especializados**. A expansão será natural e incremental, mantendo a robustez e performance existentes.

README copy.md

@@ -0,0 +1,366 @@
+# 🤖 AgentGraph - Plataforma Multi-Agente LangGraph
+
+Uma plataforma inteligente de agentes especializados que utiliza LangGraph para processar consultas em linguagem natural, com suporte a múltiplos provedores de LLM e arquitetura modular extensível.
+
+## ✨ Funcionalidades Principais
+
+### 🎯 **Sistema Multi-Agente**
+- **Agente SQL**: Consultas inteligentes em dados CSV/SQLite
+- **Detecção Automática**: Identifica tipo de processamento necessário
+- **Arquitetura Extensível**: Preparado para PDF, MySQL, Gráficos e ML
+
+### 🧠 **Múltiplos Provedores LLM**
+- **OpenAI**: GPT-4o, GPT-4o-mini, o3-mini
+- **Anthropic**: Claude-3.5-Sonnet com tool-calling
+- **HuggingFace**: LLaMA 70B, LLaMA 8B, DeepSeek-R1 (refinamento)
+
+### 🔄 **LangGraph Avançado**
+- Arquitetura baseada em nós especializados
+- Processamento assíncrono e paralelo
+- Gerenciamento inteligente de objetos não-serializáveis
+- Sistema de retry com backoff exponencial
+
+### 🔍 **Observabilidade com LangSmith**
+- Rastreamento completo de execuções LangGraph
+- Monitoramento de performance em tempo real
+- Debug avançado de agentes e fluxos
+- Análise de custos e uso de tokens
+- Dashboards de observabilidade integrados
+
+### 🌐 **Interface Moderna**
+- Interface Gradio responsiva e centralizada
+- Configurações separadas do chat principal
+- Upload de CSV com processamento automático
+- Histórico detalhado e logs estruturados
+
+### 💾 **Sistema Inteligente**
+- Cache otimizado com verificação de hits
+- Processamento genérico de CSV com detecção automática
+- Modo avançado com refinamento de respostas
+- Verbose ativo para debugging
+
+## 📁 Estrutura do Projeto
+
+```
+agentgraph/
+├── app.py                     # 🚀 Entry point: Gradio + LangGraph
+├── graphs/
+│   └── main_graph.py          # 🔄 StateGraph principal com roteamento
+├── nodes/                     # 🎯 Nós especializados
+│   ├── csv_processing_node.py # 📊 Processamento genérico de CSV
+│   ├── database_node.py       # 🗄️ Operações de banco de dados
+│   ├── query_node.py          # 🔍 Processamento de consultas
+│   ├── refinement_node.py     # ✨ Refinamento de respostas
+│   ├── cache_node.py          # 💾 Gerenciamento de cache
+│   └── agent_node.py          # 🤖 Coordenação geral
+├── agents/                    # 🧠 Agentes especializados
+│   ├── sql_agent.py           # 📝 Agente SQL multi-provedor
+│   └── tools.py               # 🛠️ Ferramentas e detecção
+├── utils/                     # ⚙️ Utilitários
+│   ├── database.py            # 🗃️ Funções de banco de dados
+│   ├── config.py              # 📋 Configurações centralizadas
+│   └── object_manager.py      # 🎛️ Gerenciador de objetos
+├── uploaded_data/             # 📂 Arquivos CSV enviados
+├── requirements.txt           # 📦 Dependências
+├── README.md                  # 📖 Documentação
+├── architecture.md            # 🏗️ Arquitetura detalhada
+└── .env                       # 🔐 Variáveis de ambiente
+```
+
+## 🚀 Instalação Rápida
+
+### 1. **Clone o Repositório**
+```bash
+git clone https://github.com/seu-usuario/agentgraph.git
+cd agentgraph
+```
+
+### 2. **Instale as Dependências**
+```bash
+pip install -r requirements.txt
+```
+
+### 3. **Configure as Variáveis de Ambiente**
+Crie/edite o arquivo `.env`:
+
+```env
+# 🔑 API Keys (pelo menos uma é obrigatória)
+HUGGINGFACE_API_KEY=hf_your_key_here
+OPENAI_API_KEY=sk-your_key_here
+ANTHROPIC_API_KEY=sk-ant-your_key_here
+
+# 🔍 LangSmith - Observabilidade (OPCIONAL)
+LANGSMITH_API_KEY=lsv2_pt_your_key_here
+LANGSMITH_TRACING=true
+LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+LANGSMITH_PROJECT=agentgraph-project
+
+# 🗄️ Configurações de Banco
+SQL_DB_PATH=data.db
+DEFAULT_CSV_PATH=tabela.csv
+UPLOAD_DIR=uploaded_data
+
+# 🤖 Configurações de Modelo
+DEFAULT_MODEL=GPT-4o-mini
+MAX_ITERATIONS=40
+TEMPERATURE=0
+
+# 🌐 Configurações do Gradio
+GRADIO_SHARE=False
+GRADIO_PORT=7860
+```
+
+### 4. **Execute a Aplicação**
+```bash
+python app.py
+```
+
+🎉 **Pronto!** Acesse `http://localhost:7860` no seu navegador.
+
+### 5. **Configure LangSmith (Opcional)**
+Para habilitar observabilidade avançada:
+
+1. **Crie conta** em [LangSmith](https://smith.langchain.com/)
+2. **Obtenha API Key** no dashboard
+3. **Configure no .env**:
+   ```env
+   LANGSMITH_API_KEY=lsv2_pt_your_key_here
+   LANGSMITH_TRACING=true
+   LANGSMITH_PROJECT=agentgraph-project
+   ```
+4. **Reinicie** a aplicação
+
+✨ **Com LangSmith você terá**:
+- 🔍 Rastreamento completo de execuções
+- 📊 Dashboards de performance
+- 🐛 Debug avançado de agentes
+- 💰 Análise de custos de tokens
+- 📈 Métricas de uso em tempo real
+
+## 💡 Como Usar
+
+### 🎯 **Fluxo Básico**
+1. **Acesse** `http://localhost:7860`
+2. **Selecione** o modelo LLM desejado (OpenAI, Anthropic ou HuggingFace)
+3. **Upload** de CSV (opcional) ou use dados padrão
+4. **Digite** perguntas em linguagem natural
+5. **Receba** respostas detalhadas com SQL e análises
+
+### 🤖 **Modelos Disponíveis**
+
+| Provedor | Modelo | Uso | Características |
+|----------|--------|-----|-----------------|
+| **OpenAI** | GPT-4o | AgentSQL | Tools + Verbose ativo |
+| **OpenAI** | GPT-4o-mini | AgentSQL | Modelo padrão, rápido |
+| **OpenAI** | o3-mini | AgentSQL | Sem temperature |
+| **Anthropic** | Claude-3.5-Sonnet | AgentSQL | Tool-calling + Retry |
+| **HuggingFace** | LLaMA 70B | Refinamento | Opcional |
+| **HuggingFace** | LLaMA 8B | Refinamento | Opcional |
+| **HuggingFace** | DeepSeek-R1 | Refinamento | Opcional |
+
+### 📊 **Exemplos de Perguntas**
+```
+"Quais são os produtos com maior preço?"
+"Mostre as vendas por categoria"
+"Qual a média de idade dos clientes?"
+"Produtos com estoque baixo"
+"Análise de tendências mensais"
+```
+
+## 🧪 Verificação e Testes
+
+### **Verificação Rápida**
+```bash
+# Verifica configuração LangSmith
+python check_langsmith_setup.py
+
+# Teste completo de integração
+python test_langsmith_integration.py
+```
+
+### **Arquivos de Teste Disponíveis**
+- `check_langsmith_setup.py` - Verificação rápida de configuração
+- `test_langsmith_integration.py` - Teste completo de integração
+- `test_new_architecture.py` - Teste da arquitetura LangGraph
+- `test_graph_functionality.py` - Teste de funcionalidades de gráficos
+
+## 🛠️ Tecnologias
+
+### **Core Framework**
+- **LangGraph**: Orquestração de agentes com nós especializados
+- **LangChain**: Framework de LLM com tool-calling
+- **LangSmith**: Observabilidade e rastreamento avançado
+- **Gradio**: Interface web moderna e responsiva
+
+### **Processamento de Dados**
+- **SQLAlchemy**: ORM para banco de dados SQLite
+- **Pandas**: Processamento e análise de dados CSV
+- **SQLite**: Banco de dados embarcado
+
+### **Provedores LLM**
+- **OpenAI**: GPT-4o, GPT-4o-mini, o3-mini
+- **Anthropic**: Claude-3.5-Sonnet
+- **HuggingFace**: LLaMA, DeepSeek via Together AI
+
+### **Utilitários**
+- **AsyncIO**: Processamento assíncrono
+- **Logging**: Sistema de logs estruturados
+- **Retry**: Backoff exponencial para rate limiting
+
+## 🏗️ Arquitetura Atual
+
+### **Fluxo Principal**
+```
+Pergunta → Detecção de Tipo → AgentSQL → Refinamento (Opcional) → Resposta
+```
+
+### **Nós Especializados**
+- **🔍 Query Node**: Detecção e processamento de consultas
+- **🗄️ Database Node**: Operações de banco e CSV
+- **💾 Cache Node**: Gerenciamento de cache e histórico
+- **✨ Refinement Node**: Melhoria de respostas (modo avançado)
+- **🤖 Agent Node**: Coordenação geral do fluxo
+
+### **Características Técnicas**
+- ✅ **Async/Await**: Processamento não-bloqueante
+- ✅ **Multi-Provedor**: OpenAI, Anthropic, HuggingFace
+- ✅ **Tool-Calling**: Ferramentas SQL nativas
+- ✅ **Verbose Ativo**: Debugging detalhado
+- ✅ **Rate Limiting**: Retry automático para APIs
+- ✅ **Object Manager**: Gerenciamento de objetos não-serializáveis
+
+## 🚀 Roadmap - Implementações Futuras
+
+### **🎯 Curto Prazo (1-2 meses)**
+
+#### **📄 Agente PDF**
+```python
+# Funcionalidades planejadas:
+- Extração de texto de PDFs
+- OCR para documentos escaneados
+- Análise de estrutura de documentos
+- Busca semântica em conteúdo
+- Integração com LangGraph
+```
+
+#### **📊 Agente de Gráficos**
+```python
+# Funcionalidades planejadas:
+- Geração automática de visualizações
+- Matplotlib, Plotly, Seaborn
+- Gráficos baseados em consultas SQL
+- Exportação em múltiplos formatos
+```
+
+### **🎯 Médio Prazo (3-6 meses)**
+
+#### **🗄️ Agente MySQL**
+```python
+# Funcionalidades planejadas:
+- Conexões externas MySQL/PostgreSQL
+- Queries complexas com JOINs
+- Gerenciamento de múltiplas bases
+- Pool de conexões
+```
+
+#### **🤖 Agente de ML/Previsões**
+```python
+# Funcionalidades planejadas:
+- Modelos de Machine Learning
+- Análise de séries temporais
+- Previsões automáticas
+- Integração com scikit-learn
+```
+
+### **🎯 Longo Prazo (6+ meses)**
+
+#### **🔄 Sistema de Pipelines**
+```python
+# Funcionalidades planejadas:
+- Combinação de múltiplos agentes
+- Workflows customizáveis
+- Processamento em lote
+- Agendamento de tarefas
+```
+
+#### **🌐 API REST**
+```python
+# Funcionalidades planejadas:
+- Endpoints para cada agente
+- Autenticação e autorização
+- Rate limiting por usuário
+- Documentação OpenAPI
+```
+
+#### **☁️ Integração Cloud**
+```python
+# Funcionalidades planejadas:
+- Deploy em AWS/Azure/GCP
+- Armazenamento em nuvem
+- Escalabilidade automática
+- Monitoramento avançado
+```
+
+## 📈 Exemplos de Uso
+
+### **Análise de Vendas**
+```
+Usuário: "Quais produtos tiveram maior crescimento no último trimestre?"
+
+Sistema:
+1. 🔍 Detecta: consulta SQL
+2. 🧠 Claude analisa estrutura da tabela
+3. 📝 Gera SQL otimizado
+4. 📊 Executa e analisa resultados
+5. ��� Resposta detalhada em português
+```
+
+### **Relatório Financeiro**
+```
+Usuário: "Mostre um resumo das receitas por categoria"
+
+Sistema:
+1. 🔍 Identifica: agregação de dados
+2. 🧠 GPT-4o cria query com GROUP BY
+3. 📊 Executa com LIMIT 20
+4. ✨ Refinamento opcional com LLaMA
+5. 📈 Resposta com insights
+```
+
+## 🤝 Contribuição
+
+### **Como Contribuir**
+1. **Fork** o repositório
+2. **Crie** uma branch para sua feature (`git checkout -b feature/nova-funcionalidade`)
+3. **Commit** suas mudanças (`git commit -am 'Adiciona nova funcionalidade'`)
+4. **Push** para a branch (`git push origin feature/nova-funcionalidade`)
+5. **Abra** um Pull Request
+
+### **Áreas de Contribuição**
+- 🐛 **Bug fixes** e melhorias
+- 📄 **Documentação** e exemplos
+- 🧪 **Testes** automatizados
+- 🎯 **Novos agentes** (PDF, MySQL, etc.)
+- 🎨 **Interface** e UX
+- ⚡ **Performance** e otimizações
+
+## 📄 Licença
+
+Este projeto está licenciado sob a [MIT License](LICENSE).
+
+## 🙏 Agradecimentos
+
+- **LangChain** e **LangGraph** pela framework excepcional
+- **Anthropic**, **OpenAI** e **HuggingFace** pelos modelos LLM
+- **Gradio** pela interface web intuitiva
+- Comunidade open source pelas contribuições
+
+---
+
+**⭐ Se este projeto foi útil, considere dar uma estrela no GitHub!**
+
+**🔗 Links Úteis:**
+- [Documentação Detalhada](architecture.md)
+- [Exemplos de Uso](examples/)
+- [Issues e Sugestões](https://github.com/seu-usuario/agentgraph/issues)
+- [Discussões](https://github.com/seu-usuario/agentgraph/discussions)

agentchain.md

@@ -0,0 +1,361 @@
+import os
+import time
+import shutil
+import pandas as pd
+from sqlalchemy import create_engine
+from langchain_openai import ChatOpenAI
+from langchain_community.agent_toolkits import create_sql_agent
+from langchain_community.utilities import SQLDatabase
+from huggingface_hub import InferenceClient
+import gradio as gr
+from dotenv import load_dotenv
+import logging
+from sqlalchemy.types import DateTime, Integer, Float
+
+load_dotenv()
+
+UPLOAD_DIR = "uploaded_data"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+DEFAULT_CSV_PATH = "tabela.csv"
+UPLOADED_CSV_PATH = os.path.join(UPLOAD_DIR, "tabela.csv")
+SQL_DB_PATH = "data.db"
+
+HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+
+LLAMA_MODELS = {
+    "LLaMA 70B": "meta-llama/Llama-3.3-70B-Instruct",
+    "LlaMA 8B": "meta-llama/Llama-3.1-8B-Instruct",
+    "Qwen 32B": "Qwen/QwQ-32B"
+}
+
+MAX_TOKENS_MAP = {
+    "meta-llama/Llama-3.3-70B-Instruct": 900,
+    "meta-llama/Llama-3.1-8B-Instruct": 700,
+    "Qwen/QwQ-32B": 8192
+}
+
+hf_client = InferenceClient(
+    provider="together", api_key=HUGGINGFACE_API_KEY
+)
+
+os.environ["OPENAI_API_KEY"] = OPENAI_API_KEY
+
+query_cache = {}
+history_log = []  
+recent_history = []  
+show_history_flag = False
+engine = None 
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+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 create_engine_and_load_db(csv_path, sql_db_path):
+    if os.path.exists(sql_db_path):
+        print("Banco de dados SQL já existe. Carregando...")
+        return create_engine(f"sqlite:///{sql_db_path}")
+    else:
+        print("Banco de dados SQL não encontrado. Criando...")
+        engine = create_engine(f"sqlite:///{sql_db_path}")
+
+        df = pd.read_csv(
+            csv_path,
+            sep=";",
+            encoding='utf-8',
+            parse_dates=["DATA_INICIAL", "DATA_FINAL"],
+            dayfirst=True,
+            on_bad_lines="skip"
+        )
+
+        colunas_para_float = [
+            "PRECO_VISTA", "PRECO_CHEIO"
+        ]
+
+        colunas_para_int = [
+            "QUANTIDADE", "TOTAL_PAGINAS_CAPA", "VALOR_MEDIDA", "DIAS_VALIDADE"
+        ]
+
+        for col in colunas_para_float:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col].replace("-", None), errors="coerce")
+
+        for col in colunas_para_int:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col].replace("-", None), errors="coerce")
+                df[col] = df[col].where(df[col].dropna() == df[col].dropna().astype(int))
+                df[col] = df[col].astype("Int64")
+
+        sql_dtype = {
+            "DATA_INICIAL": DateTime(),
+            "DATA_FINAL": DateTime(),
+            "QUANTIDADE": Integer(),
+            "PRECO_VISTA": Float(),
+            "PRECO_CHEIO": Float(),
+            "TOTAL_PAGINAS_CAPA": Integer(),
+            "VALOR_MEDIDA": Integer(),
+            "DIAS_VALIDADE": Integer()
+
+        }
+
+        print("[DEBUG] Tipos das colunas:")
+        print(df.dtypes)
+
+        df.to_sql("tabela", engine, index=False, if_exists="replace", dtype=sql_dtype)
+        print("Banco de dados SQL criado com sucesso!")
+        return engine
+
+def handle_csv_upload(file):
+    global engine, db, sql_agent
+
+    try:
+        file_path = file.name
+        shutil.copy(file_path, UPLOADED_CSV_PATH)
+        logging.info(f"[UPLOAD] CSV salvo como: {UPLOADED_CSV_PATH}")
+
+        engine = create_engine_and_load_db(UPLOADED_CSV_PATH, SQL_DB_PATH)
+        db = SQLDatabase(engine=engine)
+        logging.info("[UPLOAD] Novo banco carregado e DB atualizado.")
+
+        sql_agent = create_sql_agent(
+            ChatOpenAI(model="gpt-4o-mini", temperature=0),
+            db=db,
+            agent_type="openai-tools",
+            verbose=True,
+            max_iterations=40,
+            return_intermediate_steps=True
+        )
+        
+        logging.info("[UPLOAD] Novo banco carregado e agente recriado. Cache limpo.")
+        query_cache.clear()
+        history_log.clear()
+        recent_history.clear()
+
+        return "✅ CSV carregado com sucesso!"
+        
+    except Exception as e:
+        logging.error(f"[ERRO] Falha ao processar novo CSV: {e}")
+        return f"❌ Erro ao processar CSV: {e}"
+
+def reset_app():
+    global engine, db, sql_agent, query_cache, history_log, recent_history
+    
+    try:
+        if os.path.exists(UPLOADED_CSV_PATH):
+            os.remove(UPLOADED_CSV_PATH)
+            logging.info("[RESET] CSV personalizado removido.")
+            
+        engine = create_engine_and_load_db(DEFAULT_CSV_PATH, SQL_DB_PATH)
+        db = SQLDatabase(engine=engine)
+        sql_agent = create_sql_agent(ChatOpenAI(model="gpt-4o-mini", temperature=0), db=db, agent_type="openai-tools", verbose=True, max_iterations=40, return_intermediate_steps=True)
+        query_cache.clear()
+        history_log.clear()
+        recent_history.clear()
+        
+        return "🔄 Sistema resetado para o estado inicial."
+        
+    except Exception as e:
+        return f"❌ Erro ao resetar: {e}"
+
+engine = create_engine_and_load_db(get_active_csv_path(), SQL_DB_PATH)
+db = SQLDatabase(engine=engine)
+llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+sql_agent = create_sql_agent(llm, db=db, agent_type="openai-tools", verbose=True, max_iterations=40, return_intermediate_steps=True)
+
+def generate_initial_context(db_sample):
+    return (
+        f"Você é um assistente que gera queries SQL objetivas e eficientes. Sempre inclua LIMIT 20 nas queries. Aqui está o banco de dados:\n\n"
+        f"Exemplos do banco de dados:\n{db_sample.head().to_string(index=False)}\n\n"
+        "\n***IMPORTANTE***: Detecte automaticamente o idioma da pergunta do usuário e responda sempre no mesmo idioma."
+        "\nEsta base contém os SKUs (produtos) que foram promocionados por meio de TABLOIDE OU PROMOCAO OU ANUNCIO.\n"
+        "Cada linha representa um SKU OU PRODUTO único PRESENTE NO TABLOIDE OU PROMOCAO OU ANUNCIO, incluindo sua descrição completa, os veículos OU MIDIAS de promoção utilizados e o respectivo período em que a promoção ocorreu.\n"
+
+        "\nInformações imporatantes:\n"
+        "- Use `LIKE '%<palavras-chave>%'` para buscas em colunas de texto.\n"
+        "- Quando o usuário mencionar uma categoria, procure nas colunas: `CATEGORIA_PRODUTO_SKU`.\n"
+        "- Se o usuário se referir a Nestle, o jeito correto de se escrever é Nestle sem acento e não Nestlé.\n"
+        "- Você está usando um banco de dados SQLite.\n"
+        
+        "\nRetorne apenas a pergunta e a query SQL mais eficiente para entregar ao agent SQL do LangChain para gerar uma resposta para a pergunta. O formato deve ser:\n"
+        "\nPergunta: <pergunta do usuário>\n"
+        "\nOpção de Query SQL:\n<query SQL>"
+        "\nIdioma: <idioma>"
+    )
+
+def is_greeting(user_query):
+    greetings = ["olá", "oi", "bom dia", "boa tarde", "boa noite", "oi, tudo bem?"]
+    return user_query.lower().strip() in greetings
+
+def query_with_llama(user_query, db_sample, selected_model_name):
+    model_id = LLAMA_MODELS[selected_model_name]
+    max_tokens = MAX_TOKENS_MAP.get(model_id, 512)
+    
+    initial_context = generate_initial_context(db_sample)
+    formatted_history = "\n".join(
+        [f"{msg['role'].capitalize()}: {msg['content']}" for msg in recent_history[-2:]]
+    )
+    
+    full_prompt = f"{initial_context}\n\nHistórico recente:\n{formatted_history}\n\nPergunta do usuário:\n{user_query}"
+    
+    logging.info(f"[DEBUG] Contexto enviado ao ({selected_model_name}):\n{full_prompt}\n")
+    
+    start_time = time.time()
+    
+    try:
+        response = hf_client.chat.completions.create(
+            model=model_id,
+            messages=[{"role": "system", "content": full_prompt}],
+            max_tokens=max_tokens,
+            stream=False
+        )
+        
+        llama_response = response["choices"][0]["message"]["content"]
+        end_time = time.time()
+        logging.info(f"[DEBUG] Resposta do {selected_model_name} para o Agent SQL:\n{llama_response.strip()}\n[Tempo de execução: {end_time - start_time:.2f}s]\n")
+        return llama_response.strip(), model_id
+        
+    except Exception as e:
+        logging.error(f"[ERRO] Falha ao interagir com o modelo {selected_model_name}: {e}")
+        return None, model_id
+
+def query_sql_agent(user_query, selected_model_name):
+    try:
+        if user_query in query_cache:
+            print(f"[CACHE] Retornando resposta do cache para a consulta: {user_query}")
+            return query_cache[user_query]
+
+        if is_greeting(user_query):
+            greeting_response = "Olá! Estou aqui para ajudar com suas consultas. Pergunte algo relacionado aos dados carregados no agente!"
+            query_cache[user_query] = greeting_response 
+            return greeting_response
+
+        column_data = pd.read_sql_query("SELECT * FROM tabela LIMIT 10", engine)
+        llama_instruction = query_with_llama(user_query, column_data, selected_model_name)
+        
+        if not llama_instruction:
+            return "Erro: O modelo Llama não conseguiu gerar uma instrução válida."
+
+        print("------- Agent SQL: Executando query -------")
+        response = sql_agent.invoke({"input": llama_instruction})
+        sql_response = response.get("output", "Erro ao obter a resposta do agente.")
+
+        query_cache[user_query] = sql_response
+        return sql_response
+        
+    except Exception as e:
+        return f"Erro ao consultar o agente SQL: {e}"
+
+advanced_mode_enabled = False  # Novo estado global
+
+def toggle_advanced_mode(state):
+    global advanced_mode_enabled
+    advanced_mode_enabled = state
+    logging.info(f"[MODO AVANÇADO] {'Ativado' if state else 'Desativado'}")
+    return "Modo avançado ativado." if state else "Modo avançado desativado."
+
+def refine_response_with_llm(user_question, sql_response, chart_md=""):
+    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, complementar e melhorar a resposta.\n" 
+        "Adicione interpretações estatísticas ou insights relevantes."
+    )
+
+    logging.info(f"[DEBUG] Prompt enviado ao modelo de refinamento:\n{prompt}\n")
+
+    try:
+        response = hf_client.chat.completions.create(
+            model=LLAMA_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 "")
+
+def chatbot_response(user_input, selected_model_name):
+    start_time = time.time()
+    response = query_sql_agent(user_input, selected_model_name)
+    end_time = time.time()
+
+    model_id = LLAMA_MODELS[selected_model_name]
+
+    if advanced_mode_enabled:
+        response = refine_response_with_llm(user_input, response)
+
+    history_log.append({
+        "Modelo LLM": model_id,
+        "Pergunta": user_input,
+        "Resposta": response,
+        "Tempo de Resposta (s)": round(end_time - start_time, 2)
+    })
+
+    recent_history.append({"role": "user", "content": user_input})
+    recent_history.append({"role": "assistant", "content": response})
+
+    if len(recent_history) > 4:
+        recent_history.pop(0)
+        recent_history.pop(0)
+
+    return response
+
+def toggle_history():
+    global show_history_flag
+    show_history_flag = not show_history_flag
+    return history_log if show_history_flag else {}
+
+
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("## Configurações")
+            model_selector = gr.Dropdown(list(LLAMA_MODELS.keys()), value="LLaMA 70B", label="")
+            csv_file = gr.File(file_types=[".csv"], label="")
+            upload_feedback = gr.Markdown()
+            advanced_checkbox = gr.Checkbox(label="Refinar Resposta")
+            reset_btn = gr.Button("Resetar")
+
+        with gr.Column(scale=4):
+            gr.Markdown("## Reasoning Agent")
+            chatbot = gr.Chatbot(height=500)
+            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()
+            download_file = gr.File(visible=False)
+
+            def respond(message, chat_history, selected_model):
+                response = chatbot_response(message, selected_model)
+                chat_history.append((message, response))
+                return "", chat_history
+
+            def handle_csv_and_clear_chat(file):
+                feedback = handle_csv_upload(file)
+                return feedback, []
+
+            def reset_all():
+                feedback = reset_app()
+                return feedback, [], None
+
+            msg.submit(respond, [msg, chatbot, model_selector], [msg, chatbot])
+            btn.click(respond, [msg, chatbot, model_selector], [msg, chatbot])
+            history_btn.click(toggle_history, outputs=history_output)
+            csv_file.change(handle_csv_and_clear_chat, inputs=csv_file, outputs=[upload_feedback, chatbot])
+            reset_btn.click(reset_all, outputs=[upload_feedback, chatbot, csv_file])
+            advanced_checkbox.change(toggle_advanced_mode, inputs=advanced_checkbox, outputs=[])
+
+if __name__ == "__main__":
+    demo.launch(share=False)

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

app.py

@@ -0,0 +1,452 @@
+"""
+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,
+    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) -> 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
+
+    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
+        ))
+
+        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):
+    """
+    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
+
+    Returns:
+        Tupla com (mensagem_vazia, histórico_atualizado, imagem_grafico)
+    """
+    if not message.strip():
+        return "", chat_history, None
+
+    # Processa resposta
+    response, graph_image_path = chatbot_response(message, selected_model, advanced_mode)
+
+    # 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")
+
+                # 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):
+            """Wrapper para lidar com resposta e gráfico"""
+            empty_msg, updated_history, graph_path = respond(message, chat_history, model, advanced)
+
+            # 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)
+
+        msg.submit(
+            handle_response_with_graph,
+            inputs=[msg, chatbot, model_selector, advanced_checkbox],
+            outputs=[msg, chatbot, graph_image]
+        )
+
+        btn.click(
+            handle_response_with_graph,
+            inputs=[msg, chatbot, model_selector, advanced_checkbox],
+            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
+        )
+    
+    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())

env.example.txt

@@ -0,0 +1,61 @@
+# ========================================
+# AgentGraph - Configurações de Ambiente
+# ========================================
+
+# 🔑 API Keys (pelo menos uma é obrigatória)
+HUGGINGFACE_API_KEY=hf_your_key_here
+OPENAI_API_KEY=sk-your_key_here
+ANTHROPIC_API_KEY=sk-ant-your_key_here
+
+# 🔍 LangSmith - Observabilidade (OPCIONAL)
+# Obtenha sua API key em: https://smith.langchain.com/
+LANGSMITH_API_KEY=lsv2_pt_your_key_here
+LANGSMITH_TRACING=true
+LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+LANGSMITH_PROJECT=agentgraph-project
+
+# 🗄️ Configurações de Banco
+SQL_DB_PATH=data.db
+DEFAULT_CSV_PATH=tabela.csv
+UPLOAD_DIR=uploaded_data
+
+# 🤖 Configurações de Modelo
+DEFAULT_MODEL=GPT-4o-mini
+MAX_ITERATIONS=40
+TEMPERATURE=0
+
+# 🌐 Configurações do Gradio
+GRADIO_SHARE=false
+GRADIO_PORT=7860
+
+# 📊 Configurações de Logging
+LOG_LEVEL=INFO
+
+# ========================================
+# Instruções de Configuração
+# ========================================
+
+# 1. Copie este arquivo para .env:
+#    cp .env.example .env
+
+# 2. Configure pelo menos uma API key (OpenAI, Anthropic ou HuggingFace)
+
+# 3. Para habilitar LangSmith (observabilidade):
+#    - Crie conta em https://smith.langchain.com/
+#    - Obtenha sua API key
+#    - Configure LANGSMITH_API_KEY e LANGSMITH_TRACING=true
+#    - Personalize LANGSMITH_PROJECT se desejar
+
+# 4. Execute a aplicação:
+#    python app.py
+
+# ========================================
+# Benefícios do LangSmith
+# ========================================
+
+# ✅ Rastreamento completo de execuções
+# ✅ Monitoramento de performance
+# ✅ Debug de agentes LangGraph
+# ✅ Análise de custos de tokens
+# ✅ Comparação de modelos
+# ✅ Dashboards de observabilidade

graphs/main_graph.py

@@ -0,0 +1,775 @@
+"""
+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
+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.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("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
+            workflow.add_conditional_edges(
+                "check_cache",
+                lambda state: "update_history" if state.get("cache_hit") else "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,
+        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
+            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")
+
+            # 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
+            }
+            
+            # 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,126 @@
+"""
+Nó principal do agente SQL para LangGraph - Versão refatorada
+"""
+import logging
+from typing import Dict, Any, TypedDict, Optional
+
+from utils.object_manager import get_object_manager
+
+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 do gráfico, se houver
+
+async def initialize_agent_components_node(state: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Nó para inicializar componentes do agente
+
+    Args:
+        state: Estado inicial
+
+    Returns:
+        Estado com componentes inicializados
+    """
+    try:
+        obj_manager = get_object_manager()
+
+        # Verifica se os IDs necessários estão presentes
+        required_ids = ["agent_id", "engine_id", "cache_id"]
+        for id_name in required_ids:
+            if not state.get(id_name):
+                raise ValueError(f"ID necessário não encontrado: {id_name}")
+
+        # Verifica se os objetos existem
+        sql_agent = obj_manager.get_sql_agent(state["agent_id"])
+        engine = obj_manager.get_engine(state["engine_id"])
+        cache_manager = obj_manager.get_cache_manager(state["cache_id"])
+
+        if not all([sql_agent, engine, cache_manager]):
+            raise ValueError("Um ou mais componentes não foram encontrados")
+
+        state["components_ready"] = True
+        logging.info("[AGENT] Componentes inicializados com sucesso")
+
+    except Exception as e:
+        error_msg = f"Erro ao inicializar componentes: {e}"
+        logging.error(f"[AGENT] {error_msg}")
+        state["error"] = error_msg
+        state["components_ready"] = False
+
+    return state
+
+def should_refine_response(state: Dict[str, Any]) -> str:
+    """
+    Função condicional para determinar se deve refinar a resposta
+
+    Args:
+        state: Estado atual do agente
+
+    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:
+    """
+    Função condicional para determinar se deve gerar gráfico
+
+    Args:
+        state: Estado atual do agente
+
+    Returns:
+        Nome do próximo nó
+    """
+    query_type = state.get("query_type", "sql_query")
+    has_error = state.get("error") is not None
+
+    # Só gera gráfico se for sql_query_graphic e não houver erro
+    if query_type == "sql_query_graphic" and not has_error:
+        return "graph_selection"
+    else:
+        # Pula para refinamento ou cache dependendo do modo avançado
+        return should_refine_response(state)
+
+class AgentNodeManager:
+    """
+    Gerenciador dos nós do agente - versão refatorada
+    """
+
+    def __init__(self):
+        self.node_functions = {
+            "initialize_components": initialize_agent_components_node
+        }
+        self.conditional_functions = {
+            "should_refine": should_refine_response,
+            "should_generate_graph": should_generate_graph
+        }
+
+    def get_node_function(self, node_name: str):
+        """Retorna função do nó pelo nome"""
+        return self.node_functions.get(node_name)
+
+    def get_conditional_function(self, condition_name: str):
+        """Retorna função condicional pelo nome"""
+        return self.conditional_functions.get(condition_name)

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/query_node.py

@@ -0,0 +1,232 @@
+"""
+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']:
+            # Prepara contexto para envio direto ao agentSQL
+            sql_context = prepare_sql_context(user_input, db_sample)
+            state["sql_context"] = sql_context
+
+            logging.info(f"[DEBUG] Tipo de query detectado: {query_type}")
+            logging.info(f"[DEBUG] Contexto preparado para agentSQL:\n{sql_context}\n")
+        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"])
+        
+        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

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,147 @@
+"""
+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._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_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()