Delete utils

utils/config.py

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

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

@@ -1,147 +0,0 @@
-"""
-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()